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-2008, PostgreSQL Global Development Group
  15  * Portions Copyright (c) 1994, Regents of the University of California
  16  *
  17  *
  18  * IDENTIFICATION
  19  *        $PostgreSQL$
  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 /*
 217  * trigger_in           - input routine for pseudo-type TRIGGER.
 218  */
 219 Datum
 220 trigger_in(PG_FUNCTION_ARGS)
 221 {
 222         ereport(ERROR,
 223                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 224                          errmsg("cannot accept a value of type trigger")));
 225
 226         PG_RETURN_VOID();                       /* keep compiler quiet */
 227 }
 228
 229 /*
 230  * trigger_out          - output routine for pseudo-type TRIGGER.
 231  */
 232 Datum
 233 trigger_out(PG_FUNCTION_ARGS)
 234 {
 235         ereport(ERROR,
 236                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 237                          errmsg("cannot display a value of type trigger")));
 238
 239         PG_RETURN_VOID();                       /* keep compiler quiet */
 240 }
 241
 242
 243 /*
 244  * language_handler_in          - input routine for pseudo-type LANGUAGE_HANDLER.
 245  */
 246 Datum
 247 language_handler_in(PG_FUNCTION_ARGS)
 248 {
 249         ereport(ERROR,
 250                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 251                          errmsg("cannot accept a value of type language_handler")));
 252
 253         PG_RETURN_VOID();                       /* keep compiler quiet */
 254 }
 255
 256 /*
 257  * language_handler_out         - output routine for pseudo-type LANGUAGE_HANDLER.
 258  */
 259 Datum
 260 language_handler_out(PG_FUNCTION_ARGS)
 261 {
 262         ereport(ERROR,
 263                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 264                          errmsg("cannot display a value of type language_handler")));
 265
 266         PG_RETURN_VOID();                       /* keep compiler quiet */
 267 }
 268
 269
 270 /*
 271  * internal_in          - input routine for pseudo-type INTERNAL.
 272  */
 273 Datum
 274 internal_in(PG_FUNCTION_ARGS)
 275 {
 276         ereport(ERROR,
 277                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 278                          errmsg("cannot accept a value of type internal")));
 279
 280         PG_RETURN_VOID();                       /* keep compiler quiet */
 281 }
 282
 283 /*
 284  * internal_out         - output routine for pseudo-type INTERNAL.
 285  */
 286 Datum
 287 internal_out(PG_FUNCTION_ARGS)
 288 {
 289         ereport(ERROR,
 290                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 291                          errmsg("cannot display a value of type internal")));
 292
 293         PG_RETURN_VOID();                       /* keep compiler quiet */
 294 }
 295
 296
 297 /*
 298  * opaque_in            - input routine for pseudo-type OPAQUE.
 299  */
 300 Datum
 301 opaque_in(PG_FUNCTION_ARGS)
 302 {
 303         ereport(ERROR,
 304                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 305                          errmsg("cannot accept a value of type opaque")));
 306
 307         PG_RETURN_VOID();                       /* keep compiler quiet */
 308 }
 309
 310 /*
 311  * opaque_out           - output routine for pseudo-type OPAQUE.
 312  */
 313 Datum
 314 opaque_out(PG_FUNCTION_ARGS)
 315 {
 316         ereport(ERROR,
 317                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 318                          errmsg("cannot display a value of type opaque")));
 319
 320         PG_RETURN_VOID();                       /* keep compiler quiet */
 321 }
 322
 323
 324 /*
 325  * anyelement_in                - input routine for pseudo-type ANYELEMENT.
 326  */
 327 Datum
 328 anyelement_in(PG_FUNCTION_ARGS)
 329 {
 330         ereport(ERROR,
 331                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 332                          errmsg("cannot accept a value of type anyelement")));
 333
 334         PG_RETURN_VOID();                       /* keep compiler quiet */
 335 }
 336
 337 /*
 338  * anyelement_out               - output routine for pseudo-type ANYELEMENT.
 339  */
 340 Datum
 341 anyelement_out(PG_FUNCTION_ARGS)
 342 {
 343         ereport(ERROR,
 344                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 345                          errmsg("cannot display a value of type anyelement")));
 346
 347         PG_RETURN_VOID();                       /* keep compiler quiet */
 348 }
 349
 350 /*
 351  * anynonarray_in               - input routine for pseudo-type ANYNONARRAY.
 352  */
 353 Datum
 354 anynonarray_in(PG_FUNCTION_ARGS)
 355 {
 356         ereport(ERROR,
 357                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 358                          errmsg("cannot accept a value of type anynonarray")));
 359
 360         PG_RETURN_VOID();                       /* keep compiler quiet */
 361 }
 362
 363 /*
 364  * anynonarray_out              - output routine for pseudo-type ANYNONARRAY.
 365  */
 366 Datum
 367 anynonarray_out(PG_FUNCTION_ARGS)
 368 {
 369         ereport(ERROR,
 370                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 371                          errmsg("cannot display a value of type anynonarray")));
 372
 373         PG_RETURN_VOID();                       /* keep compiler quiet */
 374 }
 375
 376 /*
 377  * shell_in             - input routine for "shell" types (those not yet filled in).
 378  */
 379 Datum
 380 shell_in(PG_FUNCTION_ARGS)
 381 {
 382         ereport(ERROR,
 383                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 384                          errmsg("cannot accept a value of a shell type")));
 385
 386         PG_RETURN_VOID();                       /* keep compiler quiet */
 387 }
 388
 389 /*
 390  * shell_out            - output routine for "shell" types.
 391  */
 392 Datum
 393 shell_out(PG_FUNCTION_ARGS)
 394 {
 395         ereport(ERROR,
 396                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 397                          errmsg("cannot display a value of a shell type")));
 398
 399         PG_RETURN_VOID();                       /* keep compiler quiet */
 400 }