?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add support for user-defined I/O conversion casts.
[PostgreSQL.git] / src / backend / utils / fmgr / funcapi.c
blob2b3127131b331ee68026513d62a4446ca44e0fda
1 /*-------------------------------------------------------------------------
2 *
3 * funcapi.c
4 * Utility and convenience functions for fmgr functions that return
5 * sets and/or composite types.
6 *
7 * Copyright (c) 2002-2008, PostgreSQL Global Development Group
8 *
9 * IDENTIFICATION
10 * $PostgreSQL$
11 *
12 *-------------------------------------------------------------------------
13 */
14 #include "postgres.h"
15
16 #include "access/heapam.h"
17 #include "catalog/namespace.h"
18 #include "catalog/pg_proc.h"
19 #include "catalog/pg_type.h"
20 #include "funcapi.h"
21 #include "nodes/nodeFuncs.h"
22 #include "parser/parse_coerce.h"
23 #include "utils/array.h"
24 #include "utils/builtins.h"
25 #include "utils/lsyscache.h"
26 #include "utils/memutils.h"
27 #include "utils/syscache.h"
28 #include "utils/typcache.h"
29
30
31 static void shutdown_MultiFuncCall(Datum arg);
32 static TypeFuncClass internal_get_result_type(Oid funcid,
33 Node *call_expr,
34 ReturnSetInfo *rsinfo,
35 Oid *resultTypeId,
36 TupleDesc *resultTupleDesc);
37 static bool resolve_polymorphic_tupdesc(TupleDesc tupdesc,
38 oidvector *declared_args,
39 Node *call_expr);
40 static TypeFuncClass get_type_func_class(Oid typid);
41
42
43 /*
44 * init_MultiFuncCall
45 * Create an empty FuncCallContext data structure
46 * and do some other basic Multi-function call setup
47 * and error checking
48 */
49 FuncCallContext *
50 init_MultiFuncCall(PG_FUNCTION_ARGS)
51 {
52 FuncCallContext *retval;
53
54 /*
55 * Bail if we're called in the wrong context
56 */
57 if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo))
58 ereport(ERROR,
59 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
60 errmsg("set-valued function called in context that cannot accept a set")));
61
62 if (fcinfo->flinfo->fn_extra == NULL)
63 {
64 /*
65 * First call
66 */
67 ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
68 MemoryContext multi_call_ctx;
69
70 /*
71 * Create a suitably long-lived context to hold cross-call data
72 */
73 multi_call_ctx = AllocSetContextCreate(fcinfo->flinfo->fn_mcxt,
74 "SRF multi-call context",
75 ALLOCSET_SMALL_MINSIZE,
76 ALLOCSET_SMALL_INITSIZE,
77 ALLOCSET_SMALL_MAXSIZE);
78
79 /*
80 * Allocate suitably long-lived space and zero it
81 */
82 retval = (FuncCallContext *)
83 MemoryContextAllocZero(multi_call_ctx,
84 sizeof(FuncCallContext));
85
86 /*
87 * initialize the elements
88 */
89 retval->call_cntr = 0;
90 retval->max_calls = 0;
91 retval->slot = NULL;
92 retval->user_fctx = NULL;
93 retval->attinmeta = NULL;
94 retval->tuple_desc = NULL;
95 retval->multi_call_memory_ctx = multi_call_ctx;
96
97 /*
98 * save the pointer for cross-call use
99 */
100 fcinfo->flinfo->fn_extra = retval;
101
102 /*
103 * Ensure we will get shut down cleanly if the exprcontext is not run
104 * to completion.
105 */
106 RegisterExprContextCallback(rsi->econtext,
107 shutdown_MultiFuncCall,
108 PointerGetDatum(fcinfo->flinfo));
109 }
110 else
111 {
112 /* second and subsequent calls */
113 elog(ERROR, "init_MultiFuncCall cannot be called more than once");
114
115 /* never reached, but keep compiler happy */
116 retval = NULL;
117 }
118
119 return retval;
120 }
121
122 /*
123 * per_MultiFuncCall
124 *
125 * Do Multi-function per-call setup
126 */
127 FuncCallContext *
128 per_MultiFuncCall(PG_FUNCTION_ARGS)
129 {
130 FuncCallContext *retval = (FuncCallContext *) fcinfo->flinfo->fn_extra;
131
132 /*
133 * Clear the TupleTableSlot, if present. This is for safety's sake: the
134 * Slot will be in a long-lived context (it better be, if the
135 * FuncCallContext is pointing to it), but in most usage patterns the
136 * tuples stored in it will be in the function's per-tuple context. So at
137 * the beginning of each call, the Slot will hold a dangling pointer to an
138 * already-recycled tuple. We clear it out here.
139 *
140 * Note: use of retval->slot is obsolete as of 8.0, and we expect that it
141 * will always be NULL. This is just here for backwards compatibility in
142 * case someone creates a slot anyway.
143 */
144 if (retval->slot != NULL)
145 ExecClearTuple(retval->slot);
146
147 return retval;
148 }
149
150 /*
151 * end_MultiFuncCall
152 * Clean up after init_MultiFuncCall
153 */
154 void
155 end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx)
156 {
157 ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
158
159 /* Deregister the shutdown callback */
160 UnregisterExprContextCallback(rsi->econtext,
161 shutdown_MultiFuncCall,
162 PointerGetDatum(fcinfo->flinfo));
163
164 /* But use it to do the real work */
165 shutdown_MultiFuncCall(PointerGetDatum(fcinfo->flinfo));
166 }
167
168 /*
169 * shutdown_MultiFuncCall
170 * Shutdown function to clean up after init_MultiFuncCall
171 */
172 static void
173 shutdown_MultiFuncCall(Datum arg)
174 {
175 FmgrInfo *flinfo = (FmgrInfo *) DatumGetPointer(arg);
176 FuncCallContext *funcctx = (FuncCallContext *) flinfo->fn_extra;
177
178 /* unbind from flinfo */
179 flinfo->fn_extra = NULL;
180
181 /*
182 * Delete context that holds all multi-call data, including the
183 * FuncCallContext itself
184 */
185 MemoryContextSwitchTo(flinfo->fn_mcxt);
186 MemoryContextDelete(funcctx->multi_call_memory_ctx);
187 }
188
189
190 /*
191 * get_call_result_type
192 * Given a function's call info record, determine the kind of datatype
193 * it is supposed to return. If resultTypeId isn't NULL, *resultTypeId
194 * receives the actual datatype OID (this is mainly useful for scalar
195 * result types). If resultTupleDesc isn't NULL, *resultTupleDesc
196 * receives a pointer to a TupleDesc when the result is of a composite
197 * type, or NULL when it's a scalar result.
198 *
199 * One hard case that this handles is resolution of actual rowtypes for
200 * functions returning RECORD (from either the function's OUT parameter
201 * list, or a ReturnSetInfo context node). TYPEFUNC_RECORD is returned
202 * only when we couldn't resolve the actual rowtype for lack of information.
203 *
204 * The other hard case that this handles is resolution of polymorphism.
205 * We will never return polymorphic pseudotypes (ANYELEMENT etc), either
206 * as a scalar result type or as a component of a rowtype.
207 *
208 * This function is relatively expensive --- in a function returning set,
209 * try to call it only the first time through.
210 */
211 TypeFuncClass
212 get_call_result_type(FunctionCallInfo fcinfo,
213 Oid *resultTypeId,
214 TupleDesc *resultTupleDesc)
215 {
216 return internal_get_result_type(fcinfo->flinfo->fn_oid,
217 fcinfo->flinfo->fn_expr,
218 (ReturnSetInfo *) fcinfo->resultinfo,
219 resultTypeId,
220 resultTupleDesc);
221 }
222
223 /*
224 * get_expr_result_type
225 * As above, but work from a calling expression node tree
226 */
227 TypeFuncClass
228 get_expr_result_type(Node *expr,
229 Oid *resultTypeId,
230 TupleDesc *resultTupleDesc)
231 {
232 TypeFuncClass result;
233
234 if (expr && IsA(expr, FuncExpr))
235 result = internal_get_result_type(((FuncExpr *) expr)->funcid,
236 expr,
237 NULL,
238 resultTypeId,
239 resultTupleDesc);
240 else if (expr && IsA(expr, OpExpr))
241 result = internal_get_result_type(get_opcode(((OpExpr *) expr)->opno),
242 expr,
243 NULL,
244 resultTypeId,
245 resultTupleDesc);
246 else
247 {
248 /* handle as a generic expression; no chance to resolve RECORD */
249 Oid typid = exprType(expr);
250
251 if (resultTypeId)
252 *resultTypeId = typid;
253 if (resultTupleDesc)
254 *resultTupleDesc = NULL;
255 result = get_type_func_class(typid);
256 if (result == TYPEFUNC_COMPOSITE && resultTupleDesc)
257 *resultTupleDesc = lookup_rowtype_tupdesc_copy(typid, -1);
258 }
259
260 return result;
261 }
262
263 /*
264 * get_func_result_type
265 * As above, but work from a function's OID only
266 *
267 * This will not be able to resolve pure-RECORD results nor polymorphism.
268 */
269 TypeFuncClass
270 get_func_result_type(Oid functionId,
271 Oid *resultTypeId,
272 TupleDesc *resultTupleDesc)
273 {
274 return internal_get_result_type(functionId,
275 NULL,
276 NULL,
277 resultTypeId,
278 resultTupleDesc);
279 }
280
281 /*
282 * internal_get_result_type -- workhorse code implementing all the above
283 *
284 * funcid must always be supplied. call_expr and rsinfo can be NULL if not
285 * available. We will return TYPEFUNC_RECORD, and store NULL into
286 * *resultTupleDesc, if we cannot deduce the complete result rowtype from
287 * the available information.
288 */
289 static TypeFuncClass
290 internal_get_result_type(Oid funcid,
291 Node *call_expr,
292 ReturnSetInfo *rsinfo,
293 Oid *resultTypeId,
294 TupleDesc *resultTupleDesc)
295 {
296 TypeFuncClass result;
297 HeapTuple tp;
298 Form_pg_proc procform;
299 Oid rettype;
300 TupleDesc tupdesc;
301
302 /* First fetch the function's pg_proc row to inspect its rettype */
303 tp = SearchSysCache(PROCOID,
304 ObjectIdGetDatum(funcid),
305 0, 0, 0);
306 if (!HeapTupleIsValid(tp))
307 elog(ERROR, "cache lookup failed for function %u", funcid);
308 procform = (Form_pg_proc) GETSTRUCT(tp);
309
310 rettype = procform->prorettype;
311
312 /* Check for OUT parameters defining a RECORD result */
313 tupdesc = build_function_result_tupdesc_t(tp);
314 if (tupdesc)
315 {
316 /*
317 * It has OUT parameters, so it's basically like a regular composite
318 * type, except we have to be able to resolve any polymorphic OUT
319 * parameters.
320 */
321 if (resultTypeId)
322 *resultTypeId = rettype;
323
324 if (resolve_polymorphic_tupdesc(tupdesc,
325 &procform->proargtypes,
326 call_expr))
327 {
328 if (tupdesc->tdtypeid == RECORDOID &&
329 tupdesc->tdtypmod < 0)
330 assign_record_type_typmod(tupdesc);
331 if (resultTupleDesc)
332 *resultTupleDesc = tupdesc;
333 result = TYPEFUNC_COMPOSITE;
334 }
335 else
336 {
337 if (resultTupleDesc)
338 *resultTupleDesc = NULL;
339 result = TYPEFUNC_RECORD;
340 }
341
342 ReleaseSysCache(tp);
343
344 return result;
345 }
346
347 /*
348 * If scalar polymorphic result, try to resolve it.
349 */
350 if (IsPolymorphicType(rettype))
351 {
352 Oid newrettype = exprType(call_expr);
353
354 if (newrettype == InvalidOid) /* this probably should not happen */
355 ereport(ERROR,
356 (errcode(ERRCODE_DATATYPE_MISMATCH),
357 errmsg("could not determine actual result type for function \"%s\" declared to return type %s",
358 NameStr(procform->proname),
359 format_type_be(rettype))));
360 rettype = newrettype;
361 }
362
363 if (resultTypeId)
364 *resultTypeId = rettype;
365 if (resultTupleDesc)
366 *resultTupleDesc = NULL; /* default result */
367
368 /* Classify the result type */
369 result = get_type_func_class(rettype);
370 switch (result)
371 {
372 case TYPEFUNC_COMPOSITE:
373 if (resultTupleDesc)
374 *resultTupleDesc = lookup_rowtype_tupdesc_copy(rettype, -1);
375 /* Named composite types can't have any polymorphic columns */
376 break;
377 case TYPEFUNC_SCALAR:
378 break;
379 case TYPEFUNC_RECORD:
380 /* We must get the tupledesc from call context */
381 if (rsinfo && IsA(rsinfo, ReturnSetInfo) &&
382 rsinfo->expectedDesc != NULL)
383 {
384 result = TYPEFUNC_COMPOSITE;
385 if (resultTupleDesc)
386 *resultTupleDesc = rsinfo->expectedDesc;
387 /* Assume no polymorphic columns here, either */
388 }
389 break;
390 default:
391 break;
392 }
393
394 ReleaseSysCache(tp);
395
396 return result;
397 }
398
399 /*
400 * Given the result tuple descriptor for a function with OUT parameters,
401 * replace any polymorphic columns (ANYELEMENT etc) with correct data types
402 * deduced from the input arguments. Returns TRUE if able to deduce all types,
403 * FALSE if not.
404 */
405 static bool
406 resolve_polymorphic_tupdesc(TupleDesc tupdesc, oidvector *declared_args,
407 Node *call_expr)
408 {
409 int natts = tupdesc->natts;
410 int nargs = declared_args->dim1;
411 bool have_anyelement_result = false;
412 bool have_anyarray_result = false;
413 bool have_anynonarray = false;
414 bool have_anyenum = false;
415 Oid anyelement_type = InvalidOid;
416 Oid anyarray_type = InvalidOid;
417 int i;
418
419 /* See if there are any polymorphic outputs; quick out if not */
420 for (i = 0; i < natts; i++)
421 {
422 switch (tupdesc->attrs[i]->atttypid)
423 {
424 case ANYELEMENTOID:
425 have_anyelement_result = true;
426 break;
427 case ANYARRAYOID:
428 have_anyarray_result = true;
429 break;
430 case ANYNONARRAYOID:
431 have_anyelement_result = true;
432 have_anynonarray = true;
433 break;
434 case ANYENUMOID:
435 have_anyelement_result = true;
436 have_anyenum = true;
437 break;
438 default:
439 break;
440 }
441 }
442 if (!have_anyelement_result && !have_anyarray_result)
443 return true;
444
445 /*
446 * Otherwise, extract actual datatype(s) from input arguments. (We assume
447 * the parser already validated consistency of the arguments.)
448 */
449 if (!call_expr)
450 return false; /* no hope */
451
452 for (i = 0; i < nargs; i++)
453 {
454 switch (declared_args->values[i])
455 {
456 case ANYELEMENTOID:
457 case ANYNONARRAYOID:
458 case ANYENUMOID:
459 if (!OidIsValid(anyelement_type))
460 anyelement_type = get_call_expr_argtype(call_expr, i);
461 break;
462 case ANYARRAYOID:
463 if (!OidIsValid(anyarray_type))
464 anyarray_type = get_call_expr_argtype(call_expr, i);
465 break;
466 default:
467 break;
468 }
469 }
470
471 /* If nothing found, parser messed up */
472 if (!OidIsValid(anyelement_type) && !OidIsValid(anyarray_type))
473 return false;
474
475 /* If needed, deduce one polymorphic type from the other */
476 if (have_anyelement_result && !OidIsValid(anyelement_type))
477 anyelement_type = resolve_generic_type(ANYELEMENTOID,
478 anyarray_type,
479 ANYARRAYOID);
480 if (have_anyarray_result && !OidIsValid(anyarray_type))
481 anyarray_type = resolve_generic_type(ANYARRAYOID,
482 anyelement_type,
483 ANYELEMENTOID);
484
485 /* Enforce ANYNONARRAY if needed */
486 if (have_anynonarray && type_is_array(anyelement_type))
487 return false;
488
489 /* Enforce ANYENUM if needed */
490 if (have_anyenum && !type_is_enum(anyelement_type))
491 return false;
492
493 /* And finally replace the tuple column types as needed */
494 for (i = 0; i < natts; i++)
495 {
496 switch (tupdesc->attrs[i]->atttypid)
497 {
498 case ANYELEMENTOID:
499 case ANYNONARRAYOID:
500 case ANYENUMOID:
501 TupleDescInitEntry(tupdesc, i + 1,
502 NameStr(tupdesc->attrs[i]->attname),
503 anyelement_type,
504 -1,
505 0);
506 break;
507 case ANYARRAYOID:
508 TupleDescInitEntry(tupdesc, i + 1,
509 NameStr(tupdesc->attrs[i]->attname),
510 anyarray_type,
511 -1,
512 0);
513 break;
514 default:
515 break;
516 }
517 }
518
519 return true;
520 }
521
522 /*
523 * Given the declared argument types and modes for a function, replace any
524 * polymorphic types (ANYELEMENT etc) with correct data types deduced from the
525 * input arguments. Returns TRUE if able to deduce all types, FALSE if not.
526 * This is the same logic as resolve_polymorphic_tupdesc, but with a different
527 * argument representation.
528 *
529 * argmodes may be NULL, in which case all arguments are assumed to be IN mode.
530 */
531 bool
532 resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes,
533 Node *call_expr)
534 {
535 bool have_anyelement_result = false;
536 bool have_anyarray_result = false;
537 Oid anyelement_type = InvalidOid;
538 Oid anyarray_type = InvalidOid;
539 int inargno;
540 int i;
541
542 /* First pass: resolve polymorphic inputs, check for outputs */
543 inargno = 0;
544 for (i = 0; i < numargs; i++)
545 {
546 char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
547
548 switch (argtypes[i])
549 {
550 case ANYELEMENTOID:
551 case ANYNONARRAYOID:
552 case ANYENUMOID:
553 if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
554 have_anyelement_result = true;
555 else
556 {
557 if (!OidIsValid(anyelement_type))
558 {
559 anyelement_type = get_call_expr_argtype(call_expr,
560 inargno);
561 if (!OidIsValid(anyelement_type))
562 return false;
563 }
564 argtypes[i] = anyelement_type;
565 }
566 break;
567 case ANYARRAYOID:
568 if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
569 have_anyarray_result = true;
570 else
571 {
572 if (!OidIsValid(anyarray_type))
573 {
574 anyarray_type = get_call_expr_argtype(call_expr,
575 inargno);
576 if (!OidIsValid(anyarray_type))
577 return false;
578 }
579 argtypes[i] = anyarray_type;
580 }
581 break;
582 default:
583 break;
584 }
585 if (argmode != PROARGMODE_OUT && argmode != PROARGMODE_TABLE)
586 inargno++;
587 }
588
589 /* Done? */
590 if (!have_anyelement_result && !have_anyarray_result)
591 return true;
592
593 /* If no input polymorphics, parser messed up */
594 if (!OidIsValid(anyelement_type) && !OidIsValid(anyarray_type))
595 return false;
596
597 /* If needed, deduce one polymorphic type from the other */
598 if (have_anyelement_result && !OidIsValid(anyelement_type))
599 anyelement_type = resolve_generic_type(ANYELEMENTOID,
600 anyarray_type,
601 ANYARRAYOID);
602 if (have_anyarray_result && !OidIsValid(anyarray_type))
603 anyarray_type = resolve_generic_type(ANYARRAYOID,
604 anyelement_type,
605 ANYELEMENTOID);
606
607 /* XXX do we need to enforce ANYNONARRAY or ANYENUM here? I think not */
608
609 /* And finally replace the output column types as needed */
610 for (i = 0; i < numargs; i++)
611 {
612 switch (argtypes[i])
613 {
614 case ANYELEMENTOID:
615 case ANYNONARRAYOID:
616 case ANYENUMOID:
617 argtypes[i] = anyelement_type;
618 break;
619 case ANYARRAYOID:
620 argtypes[i] = anyarray_type;
621 break;
622 default:
623 break;
624 }
625 }
626
627 return true;
628 }
629
630 /*
631 * get_type_func_class
632 * Given the type OID, obtain its TYPEFUNC classification.
633 *
634 * This is intended to centralize a bunch of formerly ad-hoc code for
635 * classifying types. The categories used here are useful for deciding
636 * how to handle functions returning the datatype.
637 */
638 static TypeFuncClass
639 get_type_func_class(Oid typid)
640 {
641 switch (get_typtype(typid))
642 {
643 case TYPTYPE_COMPOSITE:
644 return TYPEFUNC_COMPOSITE;
645 case TYPTYPE_BASE:
646 case TYPTYPE_DOMAIN:
647 case TYPTYPE_ENUM:
648 return TYPEFUNC_SCALAR;
649 case TYPTYPE_PSEUDO:
650 if (typid == RECORDOID)
651 return TYPEFUNC_RECORD;
652
653 /*
654 * We treat VOID and CSTRING as legitimate scalar datatypes,
655 * mostly for the convenience of the JDBC driver (which wants to
656 * be able to do "SELECT * FROM foo()" for all legitimately
657 * user-callable functions).
658 */
659 if (typid == VOIDOID || typid == CSTRINGOID)
660 return TYPEFUNC_SCALAR;
661 return TYPEFUNC_OTHER;
662 }
663 /* shouldn't get here, probably */
664 return TYPEFUNC_OTHER;
665 }
666
667
668 /*
669 * get_func_arg_info
670 *
671 * Fetch info about the argument types, names, and IN/OUT modes from the
672 * pg_proc tuple. Return value is the total number of arguments.
673 * Other results are palloc'd. *p_argtypes is always filled in, but
674 * *p_argnames and *p_argmodes will be set NULL in the default cases
675 * (no names, and all IN arguments, respectively).
676 *
677 * Note that this function simply fetches what is in the pg_proc tuple;
678 * it doesn't do any interpretation of polymorphic types.
679 */
680 int
681 get_func_arg_info(HeapTuple procTup,
682 Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
683 {
684 Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup);
685 Datum proallargtypes;
686 Datum proargmodes;
687 Datum proargnames;
688 bool isNull;
689 ArrayType *arr;
690 int numargs;
691 Datum *elems;
692 int nelems;
693 int i;
694
695 /* First discover the total number of parameters and get their types */
696 proallargtypes = SysCacheGetAttr(PROCOID, procTup,
697 Anum_pg_proc_proallargtypes,
698 &isNull);
699 if (!isNull)
700 {
701 /*
702 * We expect the arrays to be 1-D arrays of the right types; verify
703 * that. For the OID and char arrays, we don't need to use
704 * deconstruct_array() since the array data is just going to look like
705 * a C array of values.
706 */
707 arr = DatumGetArrayTypeP(proallargtypes); /* ensure not toasted */
708 numargs = ARR_DIMS(arr)[0];
709 if (ARR_NDIM(arr) != 1 ||
710 numargs < 0 ||
711 ARR_HASNULL(arr) ||
712 ARR_ELEMTYPE(arr) != OIDOID)
713 elog(ERROR, "proallargtypes is not a 1-D Oid array");
714 Assert(numargs >= procStruct->pronargs);
715 *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid));
716 memcpy(*p_argtypes, ARR_DATA_PTR(arr),
717 numargs * sizeof(Oid));
718 }
719 else
720 {
721 /* If no proallargtypes, use proargtypes */
722 numargs = procStruct->proargtypes.dim1;
723 Assert(numargs == procStruct->pronargs);
724 *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid));
725 memcpy(*p_argtypes, procStruct->proargtypes.values,
726 numargs * sizeof(Oid));
727 }
728
729 /* Get argument names, if available */
730 proargnames = SysCacheGetAttr(PROCOID, procTup,
731 Anum_pg_proc_proargnames,
732 &isNull);
733 if (isNull)
734 *p_argnames = NULL;
735 else
736 {
737 deconstruct_array(DatumGetArrayTypeP(proargnames),
738 TEXTOID, -1, false, 'i',
739 &elems, NULL, &nelems);
740 if (nelems != numargs) /* should not happen */
741 elog(ERROR, "proargnames must have the same number of elements as the function has arguments");
742 *p_argnames = (char **) palloc(sizeof(char *) * numargs);
743 for (i = 0; i < numargs; i++)
744 (*p_argnames)[i] = TextDatumGetCString(elems[i]);
745 }
746
747 /* Get argument modes, if available */
748 proargmodes = SysCacheGetAttr(PROCOID, procTup,
749 Anum_pg_proc_proargmodes,
750 &isNull);
751 if (isNull)
752 *p_argmodes = NULL;
753 else
754 {
755 arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */
756 if (ARR_NDIM(arr) != 1 ||
757 ARR_DIMS(arr)[0] != numargs ||
758 ARR_HASNULL(arr) ||
759 ARR_ELEMTYPE(arr) != CHAROID)
760 elog(ERROR, "proargmodes is not a 1-D char array");
761 *p_argmodes = (char *) palloc(numargs * sizeof(char));
762 memcpy(*p_argmodes, ARR_DATA_PTR(arr),
763 numargs * sizeof(char));
764 }
765
766 return numargs;
767 }
768
769
770 /*
771 * get_func_result_name
772 *
773 * If the function has exactly one output parameter, and that parameter
774 * is named, return the name (as a palloc'd string). Else return NULL.
775 *
776 * This is used to determine the default output column name for functions
777 * returning scalar types.
778 */
779 char *
780 get_func_result_name(Oid functionId)
781 {
782 char *result;
783 HeapTuple procTuple;
784 Datum proargmodes;
785 Datum proargnames;
786 bool isnull;
787 ArrayType *arr;
788 int numargs;
789 char *argmodes;
790 Datum *argnames;
791 int numoutargs;
792 int nargnames;
793 int i;
794
795 /* First fetch the function's pg_proc row */
796 procTuple = SearchSysCache(PROCOID,
797 ObjectIdGetDatum(functionId),
798 0, 0, 0);
799 if (!HeapTupleIsValid(procTuple))
800 elog(ERROR, "cache lookup failed for function %u", functionId);
801
802 /* If there are no named OUT parameters, return NULL */
803 if (heap_attisnull(procTuple, Anum_pg_proc_proargmodes) ||
804 heap_attisnull(procTuple, Anum_pg_proc_proargnames))
805 result = NULL;
806 else
807 {
808 /* Get the data out of the tuple */
809 proargmodes = SysCacheGetAttr(PROCOID, procTuple,
810 Anum_pg_proc_proargmodes,
811 &isnull);
812 Assert(!isnull);
813 proargnames = SysCacheGetAttr(PROCOID, procTuple,
814 Anum_pg_proc_proargnames,
815 &isnull);
816 Assert(!isnull);
817
818 /*
819 * We expect the arrays to be 1-D arrays of the right types; verify
820 * that. For the char array, we don't need to use deconstruct_array()
821 * since the array data is just going to look like a C array of
822 * values.
823 */
824 arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */
825 numargs = ARR_DIMS(arr)[0];
826 if (ARR_NDIM(arr) != 1 ||
827 numargs < 0 ||
828 ARR_HASNULL(arr) ||
829 ARR_ELEMTYPE(arr) != CHAROID)
830 elog(ERROR, "proargmodes is not a 1-D char array");
831 argmodes = (char *) ARR_DATA_PTR(arr);
832 arr = DatumGetArrayTypeP(proargnames); /* ensure not toasted */
833 if (ARR_NDIM(arr) != 1 ||
834 ARR_DIMS(arr)[0] != numargs ||
835 ARR_HASNULL(arr) ||
836 ARR_ELEMTYPE(arr) != TEXTOID)
837 elog(ERROR, "proargnames is not a 1-D text array");
838 deconstruct_array(arr, TEXTOID, -1, false, 'i',
839 &argnames, NULL, &nargnames);
840 Assert(nargnames == numargs);
841
842 /* scan for output argument(s) */
843 result = NULL;
844 numoutargs = 0;
845 for (i = 0; i < numargs; i++)
846 {
847 if (argmodes[i] == PROARGMODE_IN ||
848 argmodes[i] == PROARGMODE_VARIADIC)
849 continue;
850 Assert(argmodes[i] == PROARGMODE_OUT ||
851 argmodes[i] == PROARGMODE_INOUT ||
852 argmodes[i] == PROARGMODE_TABLE);
853 if (++numoutargs > 1)
854 {
855 /* multiple out args, so forget it */
856 result = NULL;
857 break;
858 }
859 result = TextDatumGetCString(argnames[i]);
860 if (result == NULL || result[0] == '\0')
861 {
862 /* Parameter is not named, so forget it */
863 result = NULL;
864 break;
865 }
866 }
867 }
868
869 ReleaseSysCache(procTuple);
870
871 return result;
872 }
873
874
875 /*
876 * build_function_result_tupdesc_t
877 *
878 * Given a pg_proc row for a function, return a tuple descriptor for the
879 * result rowtype, or NULL if the function does not have OUT parameters.
880 *
881 * Note that this does not handle resolution of polymorphic types;
882 * that is deliberate.
883 */
884 TupleDesc
885 build_function_result_tupdesc_t(HeapTuple procTuple)
886 {
887 Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(procTuple);
888 Datum proallargtypes;
889 Datum proargmodes;
890 Datum proargnames;
891 bool isnull;
892
893 /* Return NULL if the function isn't declared to return RECORD */
894 if (procform->prorettype != RECORDOID)
895 return NULL;
896
897 /* If there are no OUT parameters, return NULL */
898 if (heap_attisnull(procTuple, Anum_pg_proc_proallargtypes) ||
899 heap_attisnull(procTuple, Anum_pg_proc_proargmodes))
900 return NULL;
901
902 /* Get the data out of the tuple */
903 proallargtypes = SysCacheGetAttr(PROCOID, procTuple,
904 Anum_pg_proc_proallargtypes,
905 &isnull);
906 Assert(!isnull);
907 proargmodes = SysCacheGetAttr(PROCOID, procTuple,
908 Anum_pg_proc_proargmodes,
909 &isnull);
910 Assert(!isnull);
911 proargnames = SysCacheGetAttr(PROCOID, procTuple,
912 Anum_pg_proc_proargnames,
913 &isnull);
914 if (isnull)
915 proargnames = PointerGetDatum(NULL); /* just to be sure */
916
917 return build_function_result_tupdesc_d(proallargtypes,
918 proargmodes,
919 proargnames);
920 }
921
922 /*
923 * build_function_result_tupdesc_d
924 *
925 * Build a RECORD function's tupledesc from the pg_proc proallargtypes,
926 * proargmodes, and proargnames arrays. This is split out for the
927 * convenience of ProcedureCreate, which needs to be able to compute the
928 * tupledesc before actually creating the function.
929 *
930 * Returns NULL if there are not at least two OUT or INOUT arguments.
931 */
932 TupleDesc
933 build_function_result_tupdesc_d(Datum proallargtypes,
934 Datum proargmodes,
935 Datum proargnames)
936 {
937 TupleDesc desc;
938 ArrayType *arr;
939 int numargs;
940 Oid *argtypes;
941 char *argmodes;
942 Datum *argnames = NULL;
943 Oid *outargtypes;
944 char **outargnames;
945 int numoutargs;
946 int nargnames;
947 int i;
948
949 /* Can't have output args if columns are null */
950 if (proallargtypes == PointerGetDatum(NULL) ||
951 proargmodes == PointerGetDatum(NULL))
952 return NULL;
953
954 /*
955 * We expect the arrays to be 1-D arrays of the right types; verify that.
956 * For the OID and char arrays, we don't need to use deconstruct_array()
957 * since the array data is just going to look like a C array of values.
958 */
959 arr = DatumGetArrayTypeP(proallargtypes); /* ensure not toasted */
960 numargs = ARR_DIMS(arr)[0];
961 if (ARR_NDIM(arr) != 1 ||
962 numargs < 0 ||
963 ARR_HASNULL(arr) ||
964 ARR_ELEMTYPE(arr) != OIDOID)
965 elog(ERROR, "proallargtypes is not a 1-D Oid array");
966 argtypes = (Oid *) ARR_DATA_PTR(arr);
967 arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */
968 if (ARR_NDIM(arr) != 1 ||
969 ARR_DIMS(arr)[0] != numargs ||
970 ARR_HASNULL(arr) ||
971 ARR_ELEMTYPE(arr) != CHAROID)
972 elog(ERROR, "proargmodes is not a 1-D char array");
973 argmodes = (char *) ARR_DATA_PTR(arr);
974 if (proargnames != PointerGetDatum(NULL))
975 {
976 arr = DatumGetArrayTypeP(proargnames); /* ensure not toasted */
977 if (ARR_NDIM(arr) != 1 ||
978 ARR_DIMS(arr)[0] != numargs ||
979 ARR_HASNULL(arr) ||
980 ARR_ELEMTYPE(arr) != TEXTOID)
981 elog(ERROR, "proargnames is not a 1-D text array");
982 deconstruct_array(arr, TEXTOID, -1, false, 'i',
983 &argnames, NULL, &nargnames);
984 Assert(nargnames == numargs);
985 }
986
987 /* zero elements probably shouldn't happen, but handle it gracefully */
988 if (numargs <= 0)
989 return NULL;
990
991 /* extract output-argument types and names */
992 outargtypes = (Oid *) palloc(numargs * sizeof(Oid));
993 outargnames = (char **) palloc(numargs * sizeof(char *));
994 numoutargs = 0;
995 for (i = 0; i < numargs; i++)
996 {
997 char *pname;
998
999 if (argmodes[i] == PROARGMODE_IN ||
1000 argmodes[i] == PROARGMODE_VARIADIC)
1001 continue;
1002 Assert(argmodes[i] == PROARGMODE_OUT ||
1003 argmodes[i] == PROARGMODE_INOUT ||
1004 argmodes[i] == PROARGMODE_TABLE);
1005 outargtypes[numoutargs] = argtypes[i];
1006 if (argnames)
1007 pname = TextDatumGetCString(argnames[i]);
1008 else
1009 pname = NULL;
1010 if (pname == NULL || pname[0] == '\0')
1011 {
1012 /* Parameter is not named, so gin up a column name */
1013 pname = (char *) palloc(32);
1014 snprintf(pname, 32, "column%d", numoutargs + 1);
1015 }
1016 outargnames[numoutargs] = pname;
1017 numoutargs++;
1018 }
1019
1020 /*
1021 * If there is no output argument, or only one, the function does not
1022 * return tuples.
1023 */
1024 if (numoutargs < 2)
1025 return NULL;
1026
1027 desc = CreateTemplateTupleDesc(numoutargs, false);
1028 for (i = 0; i < numoutargs; i++)
1029 {
1030 TupleDescInitEntry(desc, i + 1,
1031 outargnames[i],
1032 outargtypes[i],
1033 -1,
1034 0);
1035 }
1036
1037 return desc;
1038 }
1039
1040
1041 /*
1042 * RelationNameGetTupleDesc
1043 *
1044 * Given a (possibly qualified) relation name, build a TupleDesc.
1045 *
1046 * Note: while this works as advertised, it's seldom the best way to
1047 * build a tupdesc for a function's result type. It's kept around
1048 * only for backwards compatibility with existing user-written code.
1049 */
1050 TupleDesc
1051 RelationNameGetTupleDesc(const char *relname)
1052 {
1053 RangeVar *relvar;
1054 Relation rel;
1055 TupleDesc tupdesc;
1056 List *relname_list;
1057
1058 /* Open relation and copy the tuple description */
1059 relname_list = stringToQualifiedNameList(relname);
1060 relvar = makeRangeVarFromNameList(relname_list);
1061 rel = relation_openrv(relvar, AccessShareLock);
1062 tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
1063 relation_close(rel, AccessShareLock);
1064
1065 return tupdesc;
1066 }
1067
1068 /*
1069 * TypeGetTupleDesc
1070 *
1071 * Given a type Oid, build a TupleDesc. (In most cases you should be
1072 * using get_call_result_type or one of its siblings instead of this
1073 * routine, so that you can handle OUT parameters, RECORD result type,
1074 * and polymorphic results.)
1075 *
1076 * If the type is composite, *and* a colaliases List is provided, *and*
1077 * the List is of natts length, use the aliases instead of the relation
1078 * attnames. (NB: this usage is deprecated since it may result in
1079 * creation of unnecessary transient record types.)
1080 *
1081 * If the type is a base type, a single item alias List is required.
1082 */
1083 TupleDesc
1084 TypeGetTupleDesc(Oid typeoid, List *colaliases)
1085 {
1086 TypeFuncClass functypclass = get_type_func_class(typeoid);
1087 TupleDesc tupdesc = NULL;
1088
1089 /*
1090 * Build a suitable tupledesc representing the output rows
1091 */
1092 if (functypclass == TYPEFUNC_COMPOSITE)
1093 {
1094 /* Composite data type, e.g. a table's row type */
1095 tupdesc = lookup_rowtype_tupdesc_copy(typeoid, -1);
1096
1097 if (colaliases != NIL)
1098 {
1099 int natts = tupdesc->natts;
1100 int varattno;
1101
1102 /* does the list length match the number of attributes? */
1103 if (list_length(colaliases) != natts)
1104 ereport(ERROR,
1105 (errcode(ERRCODE_DATATYPE_MISMATCH),
1106 errmsg("number of aliases does not match number of columns")));
1107
1108 /* OK, use the aliases instead */
1109 for (varattno = 0; varattno < natts; varattno++)
1110 {
1111 char *label = strVal(list_nth(colaliases, varattno));
1112
1113 if (label != NULL)
1114 namestrcpy(&(tupdesc->attrs[varattno]->attname), label);
1115 }
1116
1117 /* The tuple type is now an anonymous record type */
1118 tupdesc->tdtypeid = RECORDOID;
1119 tupdesc->tdtypmod = -1;
1120 }
1121 }
1122 else if (functypclass == TYPEFUNC_SCALAR)
1123 {
1124 /* Base data type, i.e. scalar */
1125 char *attname;
1126
1127 /* the alias list is required for base types */
1128 if (colaliases == NIL)
1129 ereport(ERROR,
1130 (errcode(ERRCODE_DATATYPE_MISMATCH),
1131 errmsg("no column alias was provided")));
1132
1133 /* the alias list length must be 1 */
1134 if (list_length(colaliases) != 1)
1135 ereport(ERROR,
1136 (errcode(ERRCODE_DATATYPE_MISMATCH),
1137 errmsg("number of aliases does not match number of columns")));
1138
1139 /* OK, get the column alias */
1140 attname = strVal(linitial(colaliases));
1141
1142 tupdesc = CreateTemplateTupleDesc(1, false);
1143 TupleDescInitEntry(tupdesc,
1144 (AttrNumber) 1,
1145 attname,
1146 typeoid,
1147 -1,
1148 0);
1149 }
1150 else if (functypclass == TYPEFUNC_RECORD)
1151 {
1152 /* XXX can't support this because typmod wasn't passed in ... */
1153 ereport(ERROR,
1154 (errcode(ERRCODE_DATATYPE_MISMATCH),
1155 errmsg("could not determine row description for function returning record")));
1156 }
1157 else
1158 {
1159 /* crummy error message, but parser should have caught this */
1160 elog(ERROR, "function in FROM has unsupported return type");
1161 }
1162
1163 return tupdesc;
1164 }
PostgreSQL from CVS