← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/backend/utils/adt/pseudotypes.c

  • 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/backend/utils/adt/pseudotypes.c
 
1
/*-------------------------------------------------------------------------
 
2
 *
 
3
 * pseudotypes.c
 
4
 *        Functions for the system pseudo-types.
 
5
 *
 
6
 * A pseudo-type isn't really a type and never has any operations, but
 
7
 * we do need to supply input and output functions to satisfy the links
 
8
 * in the pseudo-type's entry in pg_type.  In most cases the functions
 
9
 * just throw an error if invoked.      (XXX the error messages here cover
 
10
 * the most common case, but might be confusing in some contexts.  Can
 
11
 * we do better?)
 
12
 *
 
13
 *
 
14
 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
 
15
 * Portions Copyright (c) 1994, Regents of the University of California
 
16
 *
 
17
 *
 
18
 * IDENTIFICATION
 
19
 *        src/backend/utils/adt/pseudotypes.c
 
20
 *
 
21
 *-------------------------------------------------------------------------
 
22
 */
 
23
#include "postgres.h"
 
24
 
 
25
#include "libpq/pqformat.h"
 
26
#include "utils/array.h"
 
27
#include "utils/builtins.h"
 
28
 
 
29
 
 
30
/*
 
31
 * cstring_in           - input routine for pseudo-type CSTRING.
 
32
 *
 
33
 * We might as well allow this to support constructs like "foo_in('blah')".
 
34
 */
 
35
Datum
 
36
cstring_in(PG_FUNCTION_ARGS)
 
37
{
 
38
        char       *str = PG_GETARG_CSTRING(0);
 
39
 
 
40
        PG_RETURN_CSTRING(pstrdup(str));
 
41
}
 
42
 
 
43
/*
 
44
 * cstring_out          - output routine for pseudo-type CSTRING.
 
45
 *
 
46
 * We allow this mainly so that "SELECT some_output_function(...)" does
 
47
 * what the user will expect.
 
48
 */
 
49
Datum
 
50
cstring_out(PG_FUNCTION_ARGS)
 
51
{
 
52
        char       *str = PG_GETARG_CSTRING(0);
 
53
 
 
54
        PG_RETURN_CSTRING(pstrdup(str));
 
55
}
 
56
 
 
57
/*
 
58
 * cstring_recv         - binary input routine for pseudo-type CSTRING.
 
59
 */
 
60
Datum
 
61
cstring_recv(PG_FUNCTION_ARGS)
 
62
{
 
63
        StringInfo      buf = (StringInfo) PG_GETARG_POINTER(0);
 
64
        char       *str;
 
65
        int                     nbytes;
 
66
 
 
67
        str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
 
68
        PG_RETURN_CSTRING(str);
 
69
}
 
70
 
 
71
/*
 
72
 * cstring_send         - binary output routine for pseudo-type CSTRING.
 
73
 */
 
74
Datum
 
75
cstring_send(PG_FUNCTION_ARGS)
 
76
{
 
77
        char       *str = PG_GETARG_CSTRING(0);
 
78
        StringInfoData buf;
 
79
 
 
80
        pq_begintypsend(&buf);
 
81
        pq_sendtext(&buf, str, strlen(str));
 
82
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 
83
}
 
84
 
 
85
 
 
86
/*
 
87
 * any_in               - input routine for pseudo-type ANY.
 
88
 */
 
89
Datum
 
90
any_in(PG_FUNCTION_ARGS)
 
91
{
 
92
        ereport(ERROR,
 
93
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
94
                         errmsg("cannot accept a value of type any")));
 
95
 
 
96
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
97
}
 
98
 
 
99
/*
 
100
 * any_out              - output routine for pseudo-type ANY.
 
101
 */
 
102
Datum
 
103
any_out(PG_FUNCTION_ARGS)
 
104
{
 
105
        ereport(ERROR,
 
106
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
107
                         errmsg("cannot display a value of type any")));
 
108
 
 
109
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
110
}
 
111
 
 
112
 
 
113
/*
 
114
 * anyarray_in          - input routine for pseudo-type ANYARRAY.
 
115
 */
 
116
Datum
 
117
anyarray_in(PG_FUNCTION_ARGS)
 
118
{
 
119
        ereport(ERROR,
 
120
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
121
                         errmsg("cannot accept a value of type anyarray")));
 
122
 
 
123
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
124
}
 
125
 
 
126
/*
 
127
 * anyarray_out         - output routine for pseudo-type ANYARRAY.
 
128
 *
 
129
 * We may as well allow this, since array_out will in fact work.
 
130
 */
 
131
Datum
 
132
anyarray_out(PG_FUNCTION_ARGS)
 
133
{
 
134
        return array_out(fcinfo);
 
135
}
 
136
 
 
137
/*
 
138
 * anyarray_recv                - binary input routine for pseudo-type ANYARRAY.
 
139
 *
 
140
 * XXX this could actually be made to work, since the incoming array
 
141
 * data will contain the element type OID.      Need to think through
 
142
 * type-safety issues before allowing it, however.
 
143
 */
 
144
Datum
 
145
anyarray_recv(PG_FUNCTION_ARGS)
 
146
{
 
147
        ereport(ERROR,
 
148
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
149
                         errmsg("cannot accept a value of type anyarray")));
 
150
 
 
151
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
152
}
 
153
 
 
154
/*
 
155
 * anyarray_send                - binary output routine for pseudo-type ANYARRAY.
 
156
 *
 
157
 * We may as well allow this, since array_send will in fact work.
 
158
 */
 
159
Datum
 
160
anyarray_send(PG_FUNCTION_ARGS)
 
161
{
 
162
        return array_send(fcinfo);
 
163
}
 
164
 
 
165
 
 
166
/*
 
167
 * anyenum_in           - input routine for pseudo-type ANYENUM.
 
168
 */
 
169
Datum
 
170
anyenum_in(PG_FUNCTION_ARGS)
 
171
{
 
172
        ereport(ERROR,
 
173
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
174
                         errmsg("cannot accept a value of type anyenum")));
 
175
 
 
176
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
177
}
 
178
 
 
179
/*
 
180
 * anyenum_out          - output routine for pseudo-type ANYENUM.
 
181
 *
 
182
 * We may as well allow this, since enum_out will in fact work.
 
183
 */
 
184
Datum
 
185
anyenum_out(PG_FUNCTION_ARGS)
 
186
{
 
187
        return enum_out(fcinfo);
 
188
}
 
189
 
 
190
 
 
191
/*
 
192
 * void_in              - input routine for pseudo-type VOID.
 
193
 *
 
194
 * We allow this so that PL functions can return VOID without any special
 
195
 * hack in the PL handler.      Whatever value the PL thinks it's returning
 
196
 * will just be ignored.
 
197
 */
 
198
Datum
 
199
void_in(PG_FUNCTION_ARGS)
 
200
{
 
201
        PG_RETURN_VOID();                       /* you were expecting something different? */
 
202
}
 
203
 
 
204
/*
 
205
 * void_out             - output routine for pseudo-type VOID.
 
206
 *
 
207
 * We allow this so that "SELECT function_returning_void(...)" works.
 
208
 */
 
209
Datum
 
210
void_out(PG_FUNCTION_ARGS)
 
211
{
 
212
        PG_RETURN_CSTRING(pstrdup(""));
 
213
}
 
214
 
 
215
/*
 
216
 * void_recv    - binary input routine for pseudo-type VOID.
 
217
 *
 
218
 * Note that since we consume no bytes, an attempt to send anything but
 
219
 * an empty string will result in an "invalid message format" error.
 
220
 */
 
221
Datum
 
222
void_recv(PG_FUNCTION_ARGS)
 
223
{
 
224
        PG_RETURN_VOID();
 
225
}
 
226
 
 
227
/*
 
228
 * void_send    - binary output routine for pseudo-type VOID.
 
229
 *
 
230
 * We allow this so that "SELECT function_returning_void(...)" works
 
231
 * even when binary output is requested.
 
232
 */
 
233
Datum
 
234
void_send(PG_FUNCTION_ARGS)
 
235
{
 
236
        StringInfoData buf;
 
237
 
 
238
        /* send an empty string */
 
239
        pq_begintypsend(&buf);
 
240
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 
241
}
 
242
 
 
243
 
 
244
/*
 
245
 * trigger_in           - input routine for pseudo-type TRIGGER.
 
246
 */
 
247
Datum
 
248
trigger_in(PG_FUNCTION_ARGS)
 
249
{
 
250
        ereport(ERROR,
 
251
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
252
                         errmsg("cannot accept a value of type trigger")));
 
253
 
 
254
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
255
}
 
256
 
 
257
/*
 
258
 * trigger_out          - output routine for pseudo-type TRIGGER.
 
259
 */
 
260
Datum
 
261
trigger_out(PG_FUNCTION_ARGS)
 
262
{
 
263
        ereport(ERROR,
 
264
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
265
                         errmsg("cannot display a value of type trigger")));
 
266
 
 
267
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
268
}
 
269
 
 
270
 
 
271
/*
 
272
 * language_handler_in          - input routine for pseudo-type LANGUAGE_HANDLER.
 
273
 */
 
274
Datum
 
275
language_handler_in(PG_FUNCTION_ARGS)
 
276
{
 
277
        ereport(ERROR,
 
278
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
279
                         errmsg("cannot accept a value of type language_handler")));
 
280
 
 
281
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
282
}
 
283
 
 
284
/*
 
285
 * language_handler_out         - output routine for pseudo-type LANGUAGE_HANDLER.
 
286
 */
 
287
Datum
 
288
language_handler_out(PG_FUNCTION_ARGS)
 
289
{
 
290
        ereport(ERROR,
 
291
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
292
                         errmsg("cannot display a value of type language_handler")));
 
293
 
 
294
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
295
}
 
296
 
 
297
 
 
298
/*
 
299
 * fdw_handler_in               - input routine for pseudo-type FDW_HANDLER.
 
300
 */
 
301
Datum
 
302
fdw_handler_in(PG_FUNCTION_ARGS)
 
303
{
 
304
        ereport(ERROR,
 
305
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
306
                         errmsg("cannot accept a value of type fdw_handler")));
 
307
 
 
308
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
309
}
 
310
 
 
311
/*
 
312
 * fdw_handler_out              - output routine for pseudo-type FDW_HANDLER.
 
313
 */
 
314
Datum
 
315
fdw_handler_out(PG_FUNCTION_ARGS)
 
316
{
 
317
        ereport(ERROR,
 
318
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
319
                         errmsg("cannot display a value of type fdw_handler")));
 
320
 
 
321
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
322
}
 
323
 
 
324
 
 
325
/*
 
326
 * internal_in          - input routine for pseudo-type INTERNAL.
 
327
 */
 
328
Datum
 
329
internal_in(PG_FUNCTION_ARGS)
 
330
{
 
331
        ereport(ERROR,
 
332
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
333
                         errmsg("cannot accept a value of type internal")));
 
334
 
 
335
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
336
}
 
337
 
 
338
/*
 
339
 * internal_out         - output routine for pseudo-type INTERNAL.
 
340
 */
 
341
Datum
 
342
internal_out(PG_FUNCTION_ARGS)
 
343
{
 
344
        ereport(ERROR,
 
345
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
346
                         errmsg("cannot display a value of type internal")));
 
347
 
 
348
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
349
}
 
350
 
 
351
 
 
352
/*
 
353
 * opaque_in            - input routine for pseudo-type OPAQUE.
 
354
 */
 
355
Datum
 
356
opaque_in(PG_FUNCTION_ARGS)
 
357
{
 
358
        ereport(ERROR,
 
359
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
360
                         errmsg("cannot accept a value of type opaque")));
 
361
 
 
362
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
363
}
 
364
 
 
365
/*
 
366
 * opaque_out           - output routine for pseudo-type OPAQUE.
 
367
 */
 
368
Datum
 
369
opaque_out(PG_FUNCTION_ARGS)
 
370
{
 
371
        ereport(ERROR,
 
372
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
373
                         errmsg("cannot display a value of type opaque")));
 
374
 
 
375
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
376
}
 
377
 
 
378
 
 
379
/*
 
380
 * anyelement_in                - input routine for pseudo-type ANYELEMENT.
 
381
 */
 
382
Datum
 
383
anyelement_in(PG_FUNCTION_ARGS)
 
384
{
 
385
        ereport(ERROR,
 
386
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
387
                         errmsg("cannot accept a value of type anyelement")));
 
388
 
 
389
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
390
}
 
391
 
 
392
/*
 
393
 * anyelement_out               - output routine for pseudo-type ANYELEMENT.
 
394
 */
 
395
Datum
 
396
anyelement_out(PG_FUNCTION_ARGS)
 
397
{
 
398
        ereport(ERROR,
 
399
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
400
                         errmsg("cannot display a value of type anyelement")));
 
401
 
 
402
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
403
}
 
404
 
 
405
/*
 
406
 * anynonarray_in               - input routine for pseudo-type ANYNONARRAY.
 
407
 */
 
408
Datum
 
409
anynonarray_in(PG_FUNCTION_ARGS)
 
410
{
 
411
        ereport(ERROR,
 
412
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
413
                         errmsg("cannot accept a value of type anynonarray")));
 
414
 
 
415
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
416
}
 
417
 
 
418
/*
 
419
 * anynonarray_out              - output routine for pseudo-type ANYNONARRAY.
 
420
 */
 
421
Datum
 
422
anynonarray_out(PG_FUNCTION_ARGS)
 
423
{
 
424
        ereport(ERROR,
 
425
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
426
                         errmsg("cannot display a value of type anynonarray")));
 
427
 
 
428
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
429
}
 
430
 
 
431
/*
 
432
 * shell_in             - input routine for "shell" types (those not yet filled in).
 
433
 */
 
434
Datum
 
435
shell_in(PG_FUNCTION_ARGS)
 
436
{
 
437
        ereport(ERROR,
 
438
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
439
                         errmsg("cannot accept a value of a shell type")));
 
440
 
 
441
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
442
}
 
443
 
 
444
/*
 
445
 * shell_out            - output routine for "shell" types.
 
446
 */
 
447
Datum
 
448
shell_out(PG_FUNCTION_ARGS)
 
449
{
 
450
        ereport(ERROR,
 
451
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
452
                         errmsg("cannot display a value of a shell type")));
 
453
 
 
454
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
455
}
 
456
 
 
457
 
 
458
/*
 
459
 * pg_node_tree_in              - input routine for type PG_NODE_TREE.
 
460
 *
 
461
 * pg_node_tree isn't really a pseudotype --- it's real enough to be a table
 
462
 * column --- but it presently has no operations of its own, and disallows
 
463
 * input too, so its I/O functions seem to fit here as much as anywhere.
 
464
 */
 
465
Datum
 
466
pg_node_tree_in(PG_FUNCTION_ARGS)
 
467
{
 
468
        /*
 
469
         * We disallow input of pg_node_tree values because the SQL functions that
 
470
         * operate on the type are not secure against malformed input.
 
471
         */
 
472
        ereport(ERROR,
 
473
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
474
                         errmsg("cannot accept a value of type pg_node_tree")));
 
475
 
 
476
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
477
}
 
478
 
 
479
/*
 
480
 * pg_node_tree_out             - output routine for type PG_NODE_TREE.
 
481
 *
 
482
 * The internal representation is the same as TEXT, so just pass it off.
 
483
 */
 
484
Datum
 
485
pg_node_tree_out(PG_FUNCTION_ARGS)
 
486
{
 
487
        return textout(fcinfo);
 
488
}
 
489
 
 
490
/*
 
491
 * pg_node_tree_recv            - binary input routine for type PG_NODE_TREE.
 
492
 */
 
493
Datum
 
494
pg_node_tree_recv(PG_FUNCTION_ARGS)
 
495
{
 
496
        ereport(ERROR,
 
497
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 
498
                         errmsg("cannot accept a value of type pg_node_tree")));
 
499
 
 
500
        PG_RETURN_VOID();                       /* keep compiler quiet */
 
501
}
 
502
 
 
503
/*
 
504
 * pg_node_tree_send            - binary output routine for type PG_NODE_TREE.
 
505
 */
 
506
Datum
 
507
pg_node_tree_send(PG_FUNCTION_ARGS)
 
508
{
 
509
        return textsend(fcinfo);
 
510
}