funcapi.h File Reference

#include "access/tupdesc.h"
#include "executor/executor.h"
#include "executor/tuptable.h"
#include "fmgr.h"

Include dependency graph for funcapi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	AttInMetadata
struct	FuncCallContext

Macros
#define	TupleGetDatum(_slot, _tuple)   HeapTupleGetDatum(_tuple)
#define	MAT_SRF_USE_EXPECTED_DESC   0x01 /* use expectedDesc as tupdesc. */
#define	MAT_SRF_BLESS
#define	SRF_IS_FIRSTCALL()   (fcinfo->flinfo->fn_extra == NULL)
#define	SRF_FIRSTCALL_INIT()   init_MultiFuncCall(fcinfo)
#define	SRF_PERCALL_SETUP()   per_MultiFuncCall(fcinfo)
#define	SRF_RETURN_NEXT(_funcctx, _result)
#define	SRF_RETURN_NEXT_NULL(_funcctx)
#define	SRF_RETURN_DONE(_funcctx)

Typedefs
typedef struct AttInMetadata	AttInMetadata
typedef struct FuncCallContext	FuncCallContext
typedef enum TypeFuncClass	TypeFuncClass

Enumerations
enum	TypeFuncClass {   TYPEFUNC_SCALAR , TYPEFUNC_COMPOSITE , TYPEFUNC_COMPOSITE_DOMAIN , TYPEFUNC_RECORD ,   TYPEFUNC_OTHER }

Functions
TypeFuncClass	get_call_result_type (FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
TypeFuncClass	get_expr_result_type (Node *expr, Oid *resultTypeId, TupleDesc *resultTupleDesc)
TypeFuncClass	get_func_result_type (Oid functionId, Oid *resultTypeId, TupleDesc *resultTupleDesc)
TupleDesc	get_expr_result_tupdesc (Node *expr, bool noError)
bool	resolve_polymorphic_argtypes (int numargs, Oid *argtypes, char *argmodes, Node *call_expr)
int	get_func_arg_info (HeapTuple procTup, Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
int	get_func_input_arg_names (Datum proargnames, Datum proargmodes, char ***arg_names)
int	get_func_trftypes (HeapTuple procTup, Oid **p_trftypes)
char *	get_func_result_name (Oid functionId)
TupleDesc	build_function_result_tupdesc_d (char prokind, Datum proallargtypes, Datum proargmodes, Datum proargnames)
TupleDesc	build_function_result_tupdesc_t (HeapTuple procTuple)
TupleDesc	RelationNameGetTupleDesc (const char *relname)
TupleDesc	TypeGetTupleDesc (Oid typeoid, List *colaliases)
TupleDesc	BlessTupleDesc (TupleDesc tupdesc)
AttInMetadata *	TupleDescGetAttInMetadata (TupleDesc tupdesc)
HeapTuple	BuildTupleFromCStrings (AttInMetadata *attinmeta, char **values)
Datum	HeapTupleHeaderGetDatum (HeapTupleHeader tuple)
static Datum	HeapTupleGetDatum (const HeapTupleData *tuple)
void	InitMaterializedSRF (FunctionCallInfo fcinfo, bits32 flags)
FuncCallContext *	init_MultiFuncCall (PG_FUNCTION_ARGS)
FuncCallContext *	per_MultiFuncCall (PG_FUNCTION_ARGS)
void	end_MultiFuncCall (PG_FUNCTION_ARGS, FuncCallContext *funcctx)
int	extract_variadic_args (FunctionCallInfo fcinfo, int variadic_start, bool convert_unknown, Datum **args, Oid **types, bool **nulls)

Macro Definition Documentation

MAT_SRF_BLESS

#define MAT_SRF_BLESS

Value:

                                             0x02   /* "Bless" a tuple descriptor with
                                             * BlessTupleDesc(). */

Definition at line 296 of file funcapi.h.

MAT_SRF_USE_EXPECTED_DESC

#define MAT_SRF_USE_EXPECTED_DESC   0x01 /* use expectedDesc as tupdesc. */

Definition at line 295 of file funcapi.h.

SRF_FIRSTCALL_INIT

#define SRF_FIRSTCALL_INIT

(

)

init_MultiFuncCall(fcinfo)

Definition at line 305 of file funcapi.h.

SRF_IS_FIRSTCALL

#define SRF_IS_FIRSTCALL

(

)

(fcinfo->flinfo->fn_extra == NULL)

Definition at line 303 of file funcapi.h.

SRF_PERCALL_SETUP

#define SRF_PERCALL_SETUP

(

)

per_MultiFuncCall(fcinfo)

Definition at line 307 of file funcapi.h.

SRF_RETURN_DONE

#define SRF_RETURN_DONE

(

_funcctx

)

Value:

    do { \
        ReturnSetInfo      *rsi; \
        end_MultiFuncCall(fcinfo, _funcctx); \
        rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
        rsi->isDone = ExprEndResult; \
        PG_RETURN_NULL(); \
    } while (0)

Definition at line 327 of file funcapi.h.

SRF_RETURN_NEXT

#define SRF_RETURN_NEXT	(		_funcctx,
			_result
	)

Value:

    do { \
        ReturnSetInfo      *rsi; \
        (_funcctx)->call_cntr++; \
        rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
        rsi->isDone = ExprMultipleResult; \
        PG_RETURN_DATUM(_result); \
    } while (0)

Definition at line 309 of file funcapi.h.

SRF_RETURN_NEXT_NULL

#define SRF_RETURN_NEXT_NULL

(

_funcctx

)

Value:

    do { \
        ReturnSetInfo      *rsi; \
        (_funcctx)->call_cntr++; \
        rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
        rsi->isDone = ExprMultipleResult; \
        PG_RETURN_NULL(); \
    } while (0)

Definition at line 318 of file funcapi.h.

TupleGetDatum

#define TupleGetDatum	(		_slot,
			_tuple
	)		HeapTupleGetDatum(_tuple)

Definition at line 235 of file funcapi.h.

Typedef Documentation

AttInMetadata

typedef struct AttInMetadata AttInMetadata

FuncCallContext

typedef struct FuncCallContext FuncCallContext

TypeFuncClass

typedef enum TypeFuncClass TypeFuncClass

Enumeration Type Documentation

TypeFuncClass

enum TypeFuncClass

Enumerator
TYPEFUNC_SCALAR
TYPEFUNC_COMPOSITE
TYPEFUNC_COMPOSITE_DOMAIN
TYPEFUNC_RECORD
TYPEFUNC_OTHER

Definition at line 146 of file funcapi.h.

{
    TYPEFUNC_SCALAR,            /* scalar result type */
    TYPEFUNC_COMPOSITE,         /* determinable rowtype result */
    TYPEFUNC_COMPOSITE_DOMAIN,  /* domain over determinable rowtype result */
    TYPEFUNC_RECORD,            /* indeterminate rowtype result */
    TYPEFUNC_OTHER              /* bogus type, eg pseudotype */
} TypeFuncClass;

Function Documentation

BlessTupleDesc()

TupleDesc BlessTupleDesc

(

TupleDesc

tupdesc

)

Definition at line 2071 of file execTuples.c.

{
    if (tupdesc->tdtypeid == RECORDOID &&
        tupdesc->tdtypmod < 0)
        assign_record_type_typmod(tupdesc);
 
    return tupdesc;             /* just for notational convenience */
}

References assign_record_type_typmod(), TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by aclexplode(), brin_metapage_info(), bt_page_items_bytea(), bt_page_items_internal(), exec_eval_datum(), ExecEvalWholeRowVar(), ExecInitExprRec(), ExecInitFunctionScan(), get_expr_result_type(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), init_sql_fcache(), InitMaterializedSRF(), pg_buffercache_pages(), pg_get_catalog_foreign_keys(), pg_get_publication_tables(), pg_lock_status(), pg_prepared_xact(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal(), pg_stats_ext_mcvlist_items(), pg_visibility_tupdesc(), pg_walfile_name_offset(), pgstathashindex(), PLy_output_setup_record(), setup_firstcall(), ssl_extension_info(), test_enc_conversion(), test_predtest(), and TupleDescGetAttInMetadata().

build_function_result_tupdesc_d()

TupleDesc build_function_result_tupdesc_d	(	char	prokind,
		Datum	proallargtypes,
		Datum	proargmodes,
		Datum	proargnames
	)

Definition at line 1743 of file funcapi.c.

{
    TupleDesc   desc;
    ArrayType  *arr;
    int         numargs;
    Oid        *argtypes;
    char       *argmodes;
    Datum      *argnames = NULL;
    Oid        *outargtypes;
    char      **outargnames;
    int         numoutargs;
    int         nargnames;
    int         i;
 
    /* Can't have output args if columns are null */
    if (proallargtypes == PointerGetDatum(NULL) ||
        proargmodes == PointerGetDatum(NULL))
        return NULL;
 
    /*
     * We expect the arrays to be 1-D arrays of the right types; verify that.
     * For the OID and char arrays, we don't need to use deconstruct_array()
     * since the array data is just going to look like a C array of values.
     */
    arr = DatumGetArrayTypeP(proallargtypes);   /* ensure not toasted */
    numargs = ARR_DIMS(arr)[0];
    if (ARR_NDIM(arr) != 1 ||
        numargs < 0 ||
        ARR_HASNULL(arr) ||
        ARR_ELEMTYPE(arr) != OIDOID)
        elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls");
    argtypes = (Oid *) ARR_DATA_PTR(arr);
    arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
    if (ARR_NDIM(arr) != 1 ||
        ARR_DIMS(arr)[0] != numargs ||
        ARR_HASNULL(arr) ||
        ARR_ELEMTYPE(arr) != CHAROID)
        elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
             numargs);
    argmodes = (char *) ARR_DATA_PTR(arr);
    if (proargnames != PointerGetDatum(NULL))
    {
        arr = DatumGetArrayTypeP(proargnames);  /* ensure not toasted */
        if (ARR_NDIM(arr) != 1 ||
            ARR_DIMS(arr)[0] != numargs ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != TEXTOID)
            elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls",
                 numargs);
        deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &nargnames);
        Assert(nargnames == numargs);
    }
 
    /* zero elements probably shouldn't happen, but handle it gracefully */
    if (numargs <= 0)
        return NULL;
 
    /* extract output-argument types and names */
    outargtypes = (Oid *) palloc(numargs * sizeof(Oid));
    outargnames = (char **) palloc(numargs * sizeof(char *));
    numoutargs = 0;
    for (i = 0; i < numargs; i++)
    {
        char       *pname;
 
        if (argmodes[i] == PROARGMODE_IN ||
            argmodes[i] == PROARGMODE_VARIADIC)
            continue;
        Assert(argmodes[i] == PROARGMODE_OUT ||
               argmodes[i] == PROARGMODE_INOUT ||
               argmodes[i] == PROARGMODE_TABLE);
        outargtypes[numoutargs] = argtypes[i];
        if (argnames)
            pname = TextDatumGetCString(argnames[i]);
        else
            pname = NULL;
        if (pname == NULL || pname[0] == '\0')
        {
            /* Parameter is not named, so gin up a column name */
            pname = psprintf("column%d", numoutargs + 1);
        }
        outargnames[numoutargs] = pname;
        numoutargs++;
    }
 
    /*
     * If there is no output argument, or only one, the function does not
     * return tuples.
     */
    if (numoutargs < 2 && prokind != PROKIND_PROCEDURE)
        return NULL;
 
    desc = CreateTemplateTupleDesc(numoutargs);
    for (i = 0; i < numoutargs; i++)
    {
        TupleDescInitEntry(desc, i + 1,
                           outargnames[i],
                           outargtypes[i],
                           -1,
                           0);
    }
 
    return desc;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert(), CreateTemplateTupleDesc(), DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, i, palloc(), PointerGetDatum(), psprintf(), TextDatumGetCString, and TupleDescInitEntry().

Referenced by build_function_result_tupdesc_t(), and ProcedureCreate().

build_function_result_tupdesc_t()

TupleDesc build_function_result_tupdesc_t

(

HeapTuple

procTuple

)

Definition at line 1697 of file funcapi.c.

{
    Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(procTuple);
    Datum       proallargtypes;
    Datum       proargmodes;
    Datum       proargnames;
    bool        isnull;
 
    /* Return NULL if the function isn't declared to return RECORD */
    if (procform->prorettype != RECORDOID)
        return NULL;
 
    /* If there are no OUT parameters, return NULL */
    if (heap_attisnull(procTuple, Anum_pg_proc_proallargtypes, NULL) ||
        heap_attisnull(procTuple, Anum_pg_proc_proargmodes, NULL))
        return NULL;
 
    /* Get the data out of the tuple */
    proallargtypes = SysCacheGetAttrNotNull(PROCOID, procTuple,
                                            Anum_pg_proc_proallargtypes);
    proargmodes = SysCacheGetAttrNotNull(PROCOID, procTuple,
                                         Anum_pg_proc_proargmodes);
    proargnames = SysCacheGetAttr(PROCOID, procTuple,
                                  Anum_pg_proc_proargnames,
                                  &isnull);
    if (isnull)
        proargnames = PointerGetDatum(NULL);    /* just to be sure */
 
    return build_function_result_tupdesc_d(procform->prokind,
                                           proallargtypes,
                                           proargmodes,
                                           proargnames);
}

References build_function_result_tupdesc_d(), GETSTRUCT, heap_attisnull(), PointerGetDatum(), PROCOID, SysCacheGetAttr(), and SysCacheGetAttrNotNull().

Referenced by CallStmtResultDesc(), internal_get_result_type(), and ProcedureCreate().

BuildTupleFromCStrings()

HeapTuple BuildTupleFromCStrings	(	AttInMetadata *	attinmeta,
		char **	values
	)

Definition at line 2135 of file execTuples.c.

{
    TupleDesc   tupdesc = attinmeta->tupdesc;
    int         natts = tupdesc->natts;
    Datum      *dvalues;
    bool       *nulls;
    int         i;
    HeapTuple   tuple;
 
    dvalues = (Datum *) palloc(natts * sizeof(Datum));
    nulls = (bool *) palloc(natts * sizeof(bool));
 
    /*
     * Call the "in" function for each non-dropped attribute, even for nulls,
     * to support domains.
     */
    for (i = 0; i < natts; i++)
    {
        if (!TupleDescAttr(tupdesc, i)->attisdropped)
        {
            /* Non-dropped attributes */
            dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
                                           values[i],
                                           attinmeta->attioparams[i],
                                           attinmeta->atttypmods[i]);
            if (values[i] != NULL)
                nulls[i] = false;
            else
                nulls[i] = true;
        }
        else
        {
            /* Handle dropped attributes by setting to NULL */
            dvalues[i] = (Datum) 0;
            nulls[i] = true;
        }
    }
 
    /*
     * Form a tuple
     */
    tuple = heap_form_tuple(tupdesc, dvalues, nulls);
 
    /*
     * Release locally palloc'd space.  XXX would probably be good to pfree
     * values of pass-by-reference datums, as well.
     */
    pfree(dvalues);
    pfree(nulls);
 
    return tuple;
}

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, heap_form_tuple(), i, InputFunctionCall(), TupleDescData::natts, palloc(), pfree(), AttInMetadata::tupdesc, TupleDescAttr, and values.

Referenced by bt_metap(), bt_multi_page_stats(), bt_page_stats_internal(), build_pgstattuple_type(), build_tuplestore_recursively(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), libpqrcv_processTuples(), materializeResult(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), prs_process_call(), show_all_settings(), storeRow(), ts_process_call(), tt_process_call(), and xpath_table().

end_MultiFuncCall()

void end_MultiFuncCall	(	PG_FUNCTION_ARGS	,
		FuncCallContext *	funcctx
	)

Definition at line 220 of file funcapi.c.

{
    ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
    /* Deregister the shutdown callback */
    UnregisterExprContextCallback(rsi->econtext,
                                  shutdown_MultiFuncCall,
                                  PointerGetDatum(fcinfo->flinfo));
 
    /* But use it to do the real work */
    shutdown_MultiFuncCall(PointerGetDatum(fcinfo->flinfo));
}

References ReturnSetInfo::econtext, PointerGetDatum(), shutdown_MultiFuncCall(), and UnregisterExprContextCallback().

extract_variadic_args()

int extract_variadic_args	(	FunctionCallInfo	fcinfo,
		int	variadic_start,
		bool	convert_unknown,
		Datum **	args,
		Oid **	types,
		bool **	nulls
	)

Definition at line 1997 of file funcapi.c.

{
    bool        variadic = get_fn_expr_variadic(fcinfo->flinfo);
    Datum      *args_res;
    bool       *nulls_res;
    Oid        *types_res;
    int         nargs,
                i;
 
    *args = NULL;
    *types = NULL;
    *nulls = NULL;
 
    if (variadic)
    {
        ArrayType  *array_in;
        Oid         element_type;
        bool        typbyval;
        char        typalign;
        int16       typlen;
 
        Assert(PG_NARGS() == variadic_start + 1);
 
        if (PG_ARGISNULL(variadic_start))
            return -1;
 
        array_in = PG_GETARG_ARRAYTYPE_P(variadic_start);
        element_type = ARR_ELEMTYPE(array_in);
 
        get_typlenbyvalalign(element_type,
                             &typlen, &typbyval, &typalign);
        deconstruct_array(array_in, element_type, typlen, typbyval,
                          typalign, &args_res, &nulls_res,
                          &nargs);
 
        /* All the elements of the array have the same type */
        types_res = (Oid *) palloc0(nargs * sizeof(Oid));
        for (i = 0; i < nargs; i++)
            types_res[i] = element_type;
    }
    else
    {
        nargs = PG_NARGS() - variadic_start;
        Assert(nargs > 0);
        nulls_res = (bool *) palloc0(nargs * sizeof(bool));
        args_res = (Datum *) palloc0(nargs * sizeof(Datum));
        types_res = (Oid *) palloc0(nargs * sizeof(Oid));
 
        for (i = 0; i < nargs; i++)
        {
            nulls_res[i] = PG_ARGISNULL(i + variadic_start);
            types_res[i] = get_fn_expr_argtype(fcinfo->flinfo,
                                               i + variadic_start);
 
            /*
             * Turn a constant (more or less literal) value that's of unknown
             * type into text if required. Unknowns come in as a cstring
             * pointer. Note: for functions declared as taking type "any", the
             * parser will not do any type conversion on unknown-type literals
             * (that is, undecorated strings or NULLs).
             */
            if (convert_unknown &&
                types_res[i] == UNKNOWNOID &&
                get_fn_expr_arg_stable(fcinfo->flinfo, i + variadic_start))
            {
                types_res[i] = TEXTOID;
 
                if (PG_ARGISNULL(i + variadic_start))
                    args_res[i] = (Datum) 0;
                else
                    args_res[i] =
                        CStringGetTextDatum(PG_GETARG_POINTER(i + variadic_start));
            }
            else
            {
                /* no conversion needed, just take the datum as given */
                args_res[i] = PG_GETARG_DATUM(i + variadic_start);
            }
 
            if (!OidIsValid(types_res[i]) ||
                (convert_unknown && types_res[i] == UNKNOWNOID))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("could not determine data type for argument %d",
                                i + 1)));
        }
    }
 
    /* Fill in results */
    *args = args_res;
    *nulls = nulls_res;
    *types = types_res;
 
    return nargs;
}

References generate_unaccent_rules::args, ARR_ELEMTYPE, array_in(), Assert(), CStringGetTextDatum, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, get_fn_expr_arg_stable(), get_fn_expr_argtype(), get_fn_expr_variadic(), get_typlenbyvalalign(), i, OidIsValid, palloc0(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_NARGS, typalign, and types.

Referenced by json_build_array(), json_build_object(), jsonb_build_array(), and jsonb_build_object().

get_call_result_type()

TypeFuncClass get_call_result_type	(	FunctionCallInfo	fcinfo,
		Oid *	resultTypeId,
		TupleDesc *	resultTupleDesc
	)

Definition at line 276 of file funcapi.c.

{
    return internal_get_result_type(fcinfo->flinfo->fn_oid,
                                    fcinfo->flinfo->fn_expr,
                                    (ReturnSetInfo *) fcinfo->resultinfo,
                                    resultTypeId,
                                    resultTupleDesc);
}

References FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_oid, internal_get_result_type(), and FunctionCallInfoBaseData::resultinfo.

Referenced by brin_metapage_info(), bt_metap(), bt_multi_page_stats(), bt_page_items_bytea(), bt_page_items_internal(), bt_page_stats_internal(), build_pgstattuple_type(), copy_replication_slot(), crosstab(), get_record_type_from_query(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gist_page_opaque_info(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), heap_page_items(), heap_tuple_infomask_flags(), init_sql_fcache(), InitMaterializedSRF(), materializeResult(), page_header(), pg_backup_stop(), pg_buffercache_pages(), pg_buffercache_summary(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_get_catalog_foreign_keys(), pg_get_keywords(), pg_get_multixact_members(), pg_get_object_address(), pg_get_wal_record_info(), pg_identify_object(), pg_identify_object_as_address(), pg_input_error_info(), pg_last_committed_xact(), pg_old_snapshot_time_mapping(), pg_partition_tree(), pg_replication_slot_advance(), pg_sequence_parameters(), pg_split_walfile_name(), pg_stat_get_wal_receiver(), pg_stat_statements_info(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs(), pg_visibility_map_summary(), pg_xact_commit_timestamp_origin(), pgp_armor_headers(), pgstatginindex_internal(), pgstathashindex(), pgstatindex_impl(), pgstattuple_approx_internal(), plperl_return_next_internal(), plperl_sv_to_datum(), plpgsql_exec_function(), pltcl_func_handler(), PLy_function_build_args(), prs_setup_firstcall(), setup_firstcall(), ssl_extension_info(), storeRow(), test_enc_conversion(), ts_setup_firstcall(), tsvector_unnest(), and tt_setup_firstcall().

get_expr_result_tupdesc()

TupleDesc get_expr_result_tupdesc	(	Node *	expr,
		bool	noError
	)

Definition at line 543 of file funcapi.c.

{
    TupleDesc   tupleDesc;
    TypeFuncClass functypclass;
 
    functypclass = get_expr_result_type(expr, NULL, &tupleDesc);
 
    if (functypclass == TYPEFUNC_COMPOSITE ||
        functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
        return tupleDesc;
 
    if (!noError)
    {
        Oid         exprTypeId = exprType(expr);
 
        if (exprTypeId != RECORDOID)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(exprTypeId))));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("record type has not been registered")));
    }
 
    return NULL;
}

References ereport, errcode(), errmsg(), ERROR, exprType(), format_type_be(), get_expr_result_type(), TYPEFUNC_COMPOSITE, and TYPEFUNC_COMPOSITE_DOMAIN.

Referenced by expandRecordVariable(), ExpandRowReference(), get_name_for_var_field(), get_rte_attribute_is_dropped(), ParseComplexProjection(), and process_function_rte_ref().

get_expr_result_type()

TypeFuncClass get_expr_result_type	(	Node *	expr,
		Oid *	resultTypeId,
		TupleDesc *	resultTupleDesc
	)

Definition at line 292 of file funcapi.c.

{
    TypeFuncClass result;
 
    if (expr && IsA(expr, FuncExpr))
        result = internal_get_result_type(((FuncExpr *) expr)->funcid,
                                          expr,
                                          NULL,
                                          resultTypeId,
                                          resultTupleDesc);
    else if (expr && IsA(expr, OpExpr))
        result = internal_get_result_type(get_opcode(((OpExpr *) expr)->opno),
                                          expr,
                                          NULL,
                                          resultTypeId,
                                          resultTupleDesc);
    else if (expr && IsA(expr, RowExpr) &&
             ((RowExpr *) expr)->row_typeid == RECORDOID)
    {
        /* We can resolve the record type by generating the tupdesc directly */
        RowExpr    *rexpr = (RowExpr *) expr;
        TupleDesc   tupdesc;
        AttrNumber  i = 1;
        ListCell   *lcc,
                   *lcn;
 
        tupdesc = CreateTemplateTupleDesc(list_length(rexpr->args));
        Assert(list_length(rexpr->args) == list_length(rexpr->colnames));
        forboth(lcc, rexpr->args, lcn, rexpr->colnames)
        {
            Node       *col = (Node *) lfirst(lcc);
            char       *colname = strVal(lfirst(lcn));
 
            TupleDescInitEntry(tupdesc, i,
                               colname,
                               exprType(col),
                               exprTypmod(col),
                               0);
            TupleDescInitEntryCollation(tupdesc, i,
                                        exprCollation(col));
            i++;
        }
        if (resultTypeId)
            *resultTypeId = rexpr->row_typeid;
        if (resultTupleDesc)
            *resultTupleDesc = BlessTupleDesc(tupdesc);
        return TYPEFUNC_COMPOSITE;
    }
    else if (expr && IsA(expr, Const) &&
             ((Const *) expr)->consttype == RECORDOID &&
             !((Const *) expr)->constisnull)
    {
        /*
         * When EXPLAIN'ing some queries with SEARCH/CYCLE clauses, we may
         * need to resolve field names of a RECORD-type Const.  The datum
         * should contain a typmod that will tell us that.
         */
        HeapTupleHeader rec;
        Oid         tupType;
        int32       tupTypmod;
 
        rec = DatumGetHeapTupleHeader(((Const *) expr)->constvalue);
        tupType = HeapTupleHeaderGetTypeId(rec);
        tupTypmod = HeapTupleHeaderGetTypMod(rec);
        if (resultTypeId)
            *resultTypeId = tupType;
        if (tupType != RECORDOID || tupTypmod >= 0)
        {
            /* Should be able to look it up */
            if (resultTupleDesc)
                *resultTupleDesc = lookup_rowtype_tupdesc_copy(tupType,
                                                               tupTypmod);
            return TYPEFUNC_COMPOSITE;
        }
        else
        {
            /* This shouldn't really happen ... */
            if (resultTupleDesc)
                *resultTupleDesc = NULL;
            return TYPEFUNC_RECORD;
        }
    }
    else
    {
        /* handle as a generic expression; no chance to resolve RECORD */
        Oid         typid = exprType(expr);
        Oid         base_typid;
 
        if (resultTypeId)
            *resultTypeId = typid;
        if (resultTupleDesc)
            *resultTupleDesc = NULL;
        result = get_type_func_class(typid, &base_typid);
        if ((result == TYPEFUNC_COMPOSITE ||
             result == TYPEFUNC_COMPOSITE_DOMAIN) &&
            resultTupleDesc)
            *resultTupleDesc = lookup_rowtype_tupdesc_copy(base_typid, -1);
    }
 
    return result;
}

References RowExpr::args, Assert(), BlessTupleDesc(), CreateTemplateTupleDesc(), DatumGetHeapTupleHeader, exprCollation(), exprType(), exprTypmod(), forboth, get_opcode(), get_type_func_class(), HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, internal_get_result_type(), IsA, lfirst, list_length(), lookup_rowtype_tupdesc_copy(), strVal, TupleDescInitEntry(), TupleDescInitEntryCollation(), TYPEFUNC_COMPOSITE, TYPEFUNC_COMPOSITE_DOMAIN, and TYPEFUNC_RECORD.

Referenced by addRangeTableEntryForFunction(), ExecInitFunctionScan(), expandRTE(), get_expr_result_tupdesc(), init_sexpr(), inline_function(), inline_set_returning_function(), and pull_up_constant_function().

get_func_arg_info()

int get_func_arg_info	(	HeapTuple	procTup,
		Oid **	p_argtypes,
		char ***	p_argnames,
		char **	p_argmodes
	)

Definition at line 1371 of file funcapi.c.

{
    Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(procTup);
    Datum       proallargtypes;
    Datum       proargmodes;
    Datum       proargnames;
    bool        isNull;
    ArrayType  *arr;
    int         numargs;
    Datum      *elems;
    int         nelems;
    int         i;
 
    /* First discover the total number of parameters and get their types */
    proallargtypes = SysCacheGetAttr(PROCOID, procTup,
                                     Anum_pg_proc_proallargtypes,
                                     &isNull);
    if (!isNull)
    {
        /*
         * We expect the arrays to be 1-D arrays of the right types; verify
         * that.  For the OID and char arrays, we don't need to use
         * deconstruct_array() since the array data is just going to look like
         * a C array of values.
         */
        arr = DatumGetArrayTypeP(proallargtypes);   /* ensure not toasted */
        numargs = ARR_DIMS(arr)[0];
        if (ARR_NDIM(arr) != 1 ||
            numargs < 0 ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != OIDOID)
            elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls");
        Assert(numargs >= procStruct->pronargs);
        *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid));
        memcpy(*p_argtypes, ARR_DATA_PTR(arr),
               numargs * sizeof(Oid));
    }
    else
    {
        /* If no proallargtypes, use proargtypes */
        numargs = procStruct->proargtypes.dim1;
        Assert(numargs == procStruct->pronargs);
        *p_argtypes = (Oid *) palloc(numargs * sizeof(Oid));
        memcpy(*p_argtypes, procStruct->proargtypes.values,
               numargs * sizeof(Oid));
    }
 
    /* Get argument names, if available */
    proargnames = SysCacheGetAttr(PROCOID, procTup,
                                  Anum_pg_proc_proargnames,
                                  &isNull);
    if (isNull)
        *p_argnames = NULL;
    else
    {
        deconstruct_array_builtin(DatumGetArrayTypeP(proargnames), TEXTOID,
                                  &elems, NULL, &nelems);
        if (nelems != numargs)  /* should not happen */
            elog(ERROR, "proargnames must have the same number of elements as the function has arguments");
        *p_argnames = (char **) palloc(sizeof(char *) * numargs);
        for (i = 0; i < numargs; i++)
            (*p_argnames)[i] = TextDatumGetCString(elems[i]);
    }
 
    /* Get argument modes, if available */
    proargmodes = SysCacheGetAttr(PROCOID, procTup,
                                  Anum_pg_proc_proargmodes,
                                  &isNull);
    if (isNull)
        *p_argmodes = NULL;
    else
    {
        arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
        if (ARR_NDIM(arr) != 1 ||
            ARR_DIMS(arr)[0] != numargs ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != CHAROID)
            elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
                 numargs);
        *p_argmodes = (char *) palloc(numargs * sizeof(char));
        memcpy(*p_argmodes, ARR_DATA_PTR(arr),
               numargs * sizeof(char));
    }
 
    return numargs;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert(), DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, GETSTRUCT, i, palloc(), PROCOID, SysCacheGetAttr(), and TextDatumGetCString.

Referenced by do_compile(), make_callstmt_target(), MatchNamedCall(), pg_get_function_arg_default(), plperl_validator(), plpgsql_validator(), plsample_func_handler(), PLy_procedure_create(), print_function_arguments(), and print_function_sqlbody().

get_func_input_arg_names()

int get_func_input_arg_names	(	Datum	proargnames,
		Datum	proargmodes,
		char ***	arg_names
	)

Definition at line 1514 of file funcapi.c.

{
    ArrayType  *arr;
    int         numargs;
    Datum      *argnames;
    char       *argmodes;
    char      **inargnames;
    int         numinargs;
    int         i;
 
    /* Do nothing if null proargnames */
    if (proargnames == PointerGetDatum(NULL))
    {
        *arg_names = NULL;
        return 0;
    }
 
    /*
     * We expect the arrays to be 1-D arrays of the right types; verify that.
     * For proargmodes, we don't need to use deconstruct_array() since the
     * array data is just going to look like a C array of values.
     */
    arr = DatumGetArrayTypeP(proargnames);  /* ensure not toasted */
    if (ARR_NDIM(arr) != 1 ||
        ARR_HASNULL(arr) ||
        ARR_ELEMTYPE(arr) != TEXTOID)
        elog(ERROR, "proargnames is not a 1-D text array or it contains nulls");
    deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &numargs);
    if (proargmodes != PointerGetDatum(NULL))
    {
        arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
        if (ARR_NDIM(arr) != 1 ||
            ARR_DIMS(arr)[0] != numargs ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != CHAROID)
            elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
                 numargs);
        argmodes = (char *) ARR_DATA_PTR(arr);
    }
    else
        argmodes = NULL;
 
    /* zero elements probably shouldn't happen, but handle it gracefully */
    if (numargs <= 0)
    {
        *arg_names = NULL;
        return 0;
    }
 
    /* extract input-argument names */
    inargnames = (char **) palloc(numargs * sizeof(char *));
    numinargs = 0;
    for (i = 0; i < numargs; i++)
    {
        if (argmodes == NULL ||
            argmodes[i] == PROARGMODE_IN ||
            argmodes[i] == PROARGMODE_INOUT ||
            argmodes[i] == PROARGMODE_VARIADIC)
        {
            char       *pname = TextDatumGetCString(argnames[i]);
 
            if (pname[0] != '\0')
                inargnames[numinargs] = pname;
            else
                inargnames[numinargs] = NULL;
            numinargs++;
        }
    }
 
    *arg_names = inargnames;
    return numinargs;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, i, palloc(), PointerGetDatum(), and TextDatumGetCString.

Referenced by prepare_sql_fn_parse_info(), and ProcedureCreate().

get_func_result_name()

char* get_func_result_name

(

Oid

functionId

)

Definition at line 1599 of file funcapi.c.

{
    char       *result;
    HeapTuple   procTuple;
    Datum       proargmodes;
    Datum       proargnames;
    ArrayType  *arr;
    int         numargs;
    char       *argmodes;
    Datum      *argnames;
    int         numoutargs;
    int         nargnames;
    int         i;
 
    /* First fetch the function's pg_proc row */
    procTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
    if (!HeapTupleIsValid(procTuple))
        elog(ERROR, "cache lookup failed for function %u", functionId);
 
    /* If there are no named OUT parameters, return NULL */
    if (heap_attisnull(procTuple, Anum_pg_proc_proargmodes, NULL) ||
        heap_attisnull(procTuple, Anum_pg_proc_proargnames, NULL))
        result = NULL;
    else
    {
        /* Get the data out of the tuple */
        proargmodes = SysCacheGetAttrNotNull(PROCOID, procTuple,
                                             Anum_pg_proc_proargmodes);
        proargnames = SysCacheGetAttrNotNull(PROCOID, procTuple,
                                             Anum_pg_proc_proargnames);
 
        /*
         * We expect the arrays to be 1-D arrays of the right types; verify
         * that.  For the char array, we don't need to use deconstruct_array()
         * since the array data is just going to look like a C array of
         * values.
         */
        arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
        numargs = ARR_DIMS(arr)[0];
        if (ARR_NDIM(arr) != 1 ||
            numargs < 0 ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != CHAROID)
            elog(ERROR, "proargmodes is not a 1-D char array or it contains nulls");
        argmodes = (char *) ARR_DATA_PTR(arr);
        arr = DatumGetArrayTypeP(proargnames);  /* ensure not toasted */
        if (ARR_NDIM(arr) != 1 ||
            ARR_DIMS(arr)[0] != numargs ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != TEXTOID)
            elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls",
                 numargs);
        deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &nargnames);
        Assert(nargnames == numargs);
 
        /* scan for output argument(s) */
        result = NULL;
        numoutargs = 0;
        for (i = 0; i < numargs; i++)
        {
            if (argmodes[i] == PROARGMODE_IN ||
                argmodes[i] == PROARGMODE_VARIADIC)
                continue;
            Assert(argmodes[i] == PROARGMODE_OUT ||
                   argmodes[i] == PROARGMODE_INOUT ||
                   argmodes[i] == PROARGMODE_TABLE);
            if (++numoutargs > 1)
            {
                /* multiple out args, so forget it */
                result = NULL;
                break;
            }
            result = TextDatumGetCString(argnames[i]);
            if (result == NULL || result[0] == '\0')
            {
                /* Parameter is not named, so forget it */
                result = NULL;
                break;
            }
        }
    }
 
    ReleaseSysCache(procTuple);
 
    return result;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, Assert(), DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, heap_attisnull(), HeapTupleIsValid, i, ObjectIdGetDatum(), PROCOID, ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttrNotNull(), and TextDatumGetCString.

Referenced by chooseScalarFunctionAlias().

get_func_result_type()

TypeFuncClass get_func_result_type	(	Oid	functionId,
		Oid *	resultTypeId,
		TupleDesc *	resultTupleDesc
	)

Definition at line 403 of file funcapi.c.

{
    return internal_get_result_type(functionId,
                                    NULL,
                                    NULL,
                                    resultTypeId,
                                    resultTupleDesc);
}

References internal_get_result_type().

Referenced by fmgr_sql_validator().

get_func_trftypes()

int get_func_trftypes	(	HeapTuple	procTup,
		Oid **	p_trftypes
	)

Definition at line 1467 of file funcapi.c.

{
    Datum       protrftypes;
    ArrayType  *arr;
    int         nelems;
    bool        isNull;
 
    protrftypes = SysCacheGetAttr(PROCOID, procTup,
                                  Anum_pg_proc_protrftypes,
                                  &isNull);
    if (!isNull)
    {
        /*
         * We expect the arrays to be 1-D arrays of the right types; verify
         * that.  For the OID and char arrays, we don't need to use
         * deconstruct_array() since the array data is just going to look like
         * a C array of values.
         */
        arr = DatumGetArrayTypeP(protrftypes);  /* ensure not toasted */
        nelems = ARR_DIMS(arr)[0];
        if (ARR_NDIM(arr) != 1 ||
            nelems < 0 ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != OIDOID)
            elog(ERROR, "protrftypes is not a 1-D Oid array or it contains nulls");
        *p_trftypes = (Oid *) palloc(nelems * sizeof(Oid));
        memcpy(*p_trftypes, ARR_DATA_PTR(arr),
               nelems * sizeof(Oid));
 
        return nelems;
    }
    else
        return 0;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, DatumGetArrayTypeP, elog(), ERROR, palloc(), PROCOID, and SysCacheGetAttr().

Referenced by print_function_trftypes().

HeapTupleGetDatum()

static Datum HeapTupleGetDatum ( const HeapTupleData *  tuple )

inlinestatic

Definition at line 230 of file funcapi.h.

{
    return HeapTupleHeaderGetDatum(tuple->t_data);
}

References HeapTupleHeaderGetDatum(), and HeapTupleData::t_data.

Referenced by aclexplode(), brin_metapage_info(), bt_metap(), bt_multi_page_stats(), bt_page_print_tuples(), bt_page_stats_internal(), build_pgstattuple_type(), copy_replication_slot(), dblink_get_pkey(), exec_eval_datum(), ExecEvalConvertRowtype(), ExecEvalFieldStoreForm(), ExecEvalRow(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gist_page_opaque_info(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), heap_page_items(), heap_tuple_infomask_flags(), hstore_each(), hstore_populate_record(), page_header(), pg_backup_stop(), pg_buffercache_pages(), pg_buffercache_summary(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_get_catalog_foreign_keys(), pg_get_keywords(), pg_get_multixact_members(), pg_get_object_address(), pg_get_publication_tables(), pg_get_wal_record_info(), pg_identify_object(), pg_identify_object_as_address(), pg_input_error_info(), pg_last_committed_xact(), pg_lock_status(), pg_old_snapshot_time_mapping(), pg_partition_tree(), pg_prepared_xact(), pg_replication_slot_advance(), pg_sequence_parameters(), pg_split_walfile_name(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal(), pg_stat_get_wal_receiver(), pg_stat_statements_info(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs(), pg_visibility(), pg_visibility_map(), pg_visibility_map_rel(), pg_visibility_map_summary(), pg_visibility_rel(), pg_walfile_name_offset(), pg_xact_commit_timestamp_origin(), pgp_armor_headers(), pgstatginindex_internal(), pgstathashindex(), pgstatindex_impl(), pgstattuple_approx_internal(), plperl_hash_to_datum(), plperl_return_next_internal(), pltcl_build_tuple_result(), pltcl_func_handler(), prs_process_call(), show_all_settings(), ssl_extension_info(), test_enc_conversion(), test_predtest(), ts_process_call(), tsvector_unnest(), and tt_process_call().

HeapTupleHeaderGetDatum()

Datum HeapTupleHeaderGetDatum

(

HeapTupleHeader

tuple

)

Definition at line 2224 of file execTuples.c.

{
    Datum       result;
    TupleDesc   tupDesc;
 
    /* No work if there are no external TOAST pointers in the tuple */
    if (!HeapTupleHeaderHasExternal(tuple))
        return PointerGetDatum(tuple);
 
    /* Use the type data saved by heap_form_tuple to look up the rowtype */
    tupDesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(tuple),
                                     HeapTupleHeaderGetTypMod(tuple));
 
    /* And do the flattening */
    result = toast_flatten_tuple_to_datum(tuple,
                                          HeapTupleHeaderGetDatumLength(tuple),
                                          tupDesc);
 
    ReleaseTupleDesc(tupDesc);
 
    return result;
}

References HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, HeapTupleHeaderHasExternal, lookup_rowtype_tupdesc(), PointerGetDatum(), ReleaseTupleDesc, and toast_flatten_tuple_to_datum().

Referenced by HeapTupleGetDatum(), populate_composite(), and populate_recordset_record().

init_MultiFuncCall()

FuncCallContext* init_MultiFuncCall

(

PG_FUNCTION_ARGS

)

Definition at line 133 of file funcapi.c.

{
    FuncCallContext *retval;
 
    /*
     * Bail if we're called in the wrong context
     */
    if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that cannot accept a set")));
 
    if (fcinfo->flinfo->fn_extra == NULL)
    {
        /*
         * First call
         */
        ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
        MemoryContext multi_call_ctx;
 
        /*
         * Create a suitably long-lived context to hold cross-call data
         */
        multi_call_ctx = AllocSetContextCreate(fcinfo->flinfo->fn_mcxt,
                                               "SRF multi-call context",
                                               ALLOCSET_SMALL_SIZES);
 
        /*
         * Allocate suitably long-lived space and zero it
         */
        retval = (FuncCallContext *)
            MemoryContextAllocZero(multi_call_ctx,
                                   sizeof(FuncCallContext));
 
        /*
         * initialize the elements
         */
        retval->call_cntr = 0;
        retval->max_calls = 0;
        retval->user_fctx = NULL;
        retval->attinmeta = NULL;
        retval->tuple_desc = NULL;
        retval->multi_call_memory_ctx = multi_call_ctx;
 
        /*
         * save the pointer for cross-call use
         */
        fcinfo->flinfo->fn_extra = retval;
 
        /*
         * Ensure we will get shut down cleanly if the exprcontext is not run
         * to completion.
         */
        RegisterExprContextCallback(rsi->econtext,
                                    shutdown_MultiFuncCall,
                                    PointerGetDatum(fcinfo->flinfo));
    }
    else
    {
        /* second and subsequent calls */
        elog(ERROR, "init_MultiFuncCall cannot be called more than once");
 
        /* never reached, but keep compiler happy */
        retval = NULL;
    }
 
    return retval;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, FuncCallContext::attinmeta, FuncCallContext::call_cntr, ReturnSetInfo::econtext, elog(), ereport, errcode(), errmsg(), ERROR, IsA, FuncCallContext::max_calls, MemoryContextAllocZero(), FuncCallContext::multi_call_memory_ctx, PointerGetDatum(), RegisterExprContextCallback(), shutdown_MultiFuncCall(), FuncCallContext::tuple_desc, and FuncCallContext::user_fctx.

InitMaterializedSRF()

void InitMaterializedSRF	(	FunctionCallInfo	fcinfo,
		bits32	flags
	)

Definition at line 76 of file funcapi.c.

{
    bool        random_access;
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    Tuplestorestate *tupstore;
    MemoryContext old_context,
                per_query_ctx;
    TupleDesc   stored_tupdesc;
 
    /* check to see if caller supports returning a tuplestore */
    if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that cannot accept a set")));
    if (!(rsinfo->allowedModes & SFRM_Materialize) ||
        ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0 && rsinfo->expectedDesc == NULL))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("materialize mode required, but it is not allowed in this context")));
 
    /*
     * Store the tuplestore and the tuple descriptor in ReturnSetInfo.  This
     * must be done in the per-query memory context.
     */
    per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
    old_context = MemoryContextSwitchTo(per_query_ctx);
 
    /* build a tuple descriptor for our result type */
    if ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0)
        stored_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
    else
    {
        if (get_call_result_type(fcinfo, NULL, &stored_tupdesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
    }
 
    /* If requested, bless the tuple descriptor */
    if ((flags & MAT_SRF_BLESS) != 0)
        BlessTupleDesc(stored_tupdesc);
 
    random_access = (rsinfo->allowedModes & SFRM_Materialize_Random) != 0;
 
    tupstore = tuplestore_begin_heap(random_access, false, work_mem);
    rsinfo->returnMode = SFRM_Materialize;
    rsinfo->setResult = tupstore;
    rsinfo->setDesc = stored_tupdesc;
    MemoryContextSwitchTo(old_context);
}

References ReturnSetInfo::allowedModes, BlessTupleDesc(), CreateTupleDescCopy(), ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, elog(), ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, get_call_result_type(), if(), IsA, MAT_SRF_BLESS, MAT_SRF_USE_EXPECTED_DESC, MemoryContextSwitchTo(), FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, tuplestore_begin_heap(), TYPEFUNC_COMPOSITE, and work_mem.

Referenced by brin_page_items(), dblink_get_notify(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), get_altertable_subcmdinfo(), GetWALRecordsInfo(), gist_page_items(), gist_page_items_bytea(), pg_available_extension_versions(), pg_available_extensions(), pg_config(), pg_cursor(), pg_event_trigger_ddl_commands(), pg_event_trigger_dropped_objects(), pg_extension_update_paths(), pg_get_backend_memory_contexts(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_get_wal_block_info(), pg_hba_file_rules(), pg_ident_file_mappings(), pg_logical_slot_get_changes_guts(), pg_ls_dir(), pg_ls_dir_files(), pg_prepared_statement(), pg_show_replication_origin_status(), pg_stat_get_activity(), pg_stat_get_io(), pg_stat_get_progress_info(), pg_stat_get_recovery_prefetch(), pg_stat_get_slru(), pg_stat_get_subscription(), pg_stat_get_wal_senders(), pg_stat_statements_internal(), pg_tablespace_databases(), pgrowlocks(), postgres_fdw_get_connections(), show_all_file_settings(), text_to_table(), verify_heapam(), and xpath_table().

per_MultiFuncCall()

FuncCallContext* per_MultiFuncCall

(

PG_FUNCTION_ARGS

)

Definition at line 208 of file funcapi.c.

{
    FuncCallContext *retval = (FuncCallContext *) fcinfo->flinfo->fn_extra;
 
    return retval;
}

RelationNameGetTupleDesc()

TupleDesc RelationNameGetTupleDesc

(

const char *

relname

)

Definition at line 1862 of file funcapi.c.

{
    RangeVar   *relvar;
    Relation    rel;
    TupleDesc   tupdesc;
    List       *relname_list;
 
    /* Open relation and copy the tuple description */
    relname_list = stringToQualifiedNameList(relname, NULL);
    relvar = makeRangeVarFromNameList(relname_list);
    rel = relation_openrv(relvar, AccessShareLock);
    tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
    relation_close(rel, AccessShareLock);
 
    return tupdesc;
}

References AccessShareLock, CreateTupleDescCopy(), makeRangeVarFromNameList(), relation_close(), relation_openrv(), RelationGetDescr, relname, and stringToQualifiedNameList().

resolve_polymorphic_argtypes()

bool resolve_polymorphic_argtypes	(	int	numargs,
		Oid *	argtypes,
		char *	argmodes,
		Node *	call_expr
	)

Definition at line 1056 of file funcapi.c.

{
    bool        have_polymorphic_result = false;
    bool        have_anyelement_result = false;
    bool        have_anyarray_result = false;
    bool        have_anyrange_result = false;
    bool        have_anymultirange_result = false;
    bool        have_anycompatible_result = false;
    bool        have_anycompatible_array_result = false;
    bool        have_anycompatible_range_result = false;
    bool        have_anycompatible_multirange_result = false;
    polymorphic_actuals poly_actuals;
    polymorphic_actuals anyc_actuals;
    int         inargno;
    int         i;
 
    /*
     * First pass: resolve polymorphic inputs, check for outputs.  As in
     * resolve_polymorphic_tupdesc, we rely on the parser to have enforced
     * type consistency and coerced ANYCOMPATIBLE args to a common supertype.
     */
    memset(&poly_actuals, 0, sizeof(poly_actuals));
    memset(&anyc_actuals, 0, sizeof(anyc_actuals));
    inargno = 0;
    for (i = 0; i < numargs; i++)
    {
        char        argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
 
        switch (argtypes[i])
        {
            case ANYELEMENTOID:
            case ANYNONARRAYOID:
            case ANYENUMOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anyelement_result = true;
                }
                else
                {
                    if (!OidIsValid(poly_actuals.anyelement_type))
                    {
                        poly_actuals.anyelement_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(poly_actuals.anyelement_type))
                            return false;
                    }
                    argtypes[i] = poly_actuals.anyelement_type;
                }
                break;
            case ANYARRAYOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anyarray_result = true;
                }
                else
                {
                    if (!OidIsValid(poly_actuals.anyarray_type))
                    {
                        poly_actuals.anyarray_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(poly_actuals.anyarray_type))
                            return false;
                    }
                    argtypes[i] = poly_actuals.anyarray_type;
                }
                break;
            case ANYRANGEOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anyrange_result = true;
                }
                else
                {
                    if (!OidIsValid(poly_actuals.anyrange_type))
                    {
                        poly_actuals.anyrange_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(poly_actuals.anyrange_type))
                            return false;
                    }
                    argtypes[i] = poly_actuals.anyrange_type;
                }
                break;
            case ANYMULTIRANGEOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anymultirange_result = true;
                }
                else
                {
                    if (!OidIsValid(poly_actuals.anymultirange_type))
                    {
                        poly_actuals.anymultirange_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(poly_actuals.anymultirange_type))
                            return false;
                    }
                    argtypes[i] = poly_actuals.anymultirange_type;
                }
                break;
            case ANYCOMPATIBLEOID:
            case ANYCOMPATIBLENONARRAYOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anycompatible_result = true;
                }
                else
                {
                    if (!OidIsValid(anyc_actuals.anyelement_type))
                    {
                        anyc_actuals.anyelement_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(anyc_actuals.anyelement_type))
                            return false;
                    }
                    argtypes[i] = anyc_actuals.anyelement_type;
                }
                break;
            case ANYCOMPATIBLEARRAYOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anycompatible_array_result = true;
                }
                else
                {
                    if (!OidIsValid(anyc_actuals.anyarray_type))
                    {
                        anyc_actuals.anyarray_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(anyc_actuals.anyarray_type))
                            return false;
                    }
                    argtypes[i] = anyc_actuals.anyarray_type;
                }
                break;
            case ANYCOMPATIBLERANGEOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anycompatible_range_result = true;
                }
                else
                {
                    if (!OidIsValid(anyc_actuals.anyrange_type))
                    {
                        anyc_actuals.anyrange_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(anyc_actuals.anyrange_type))
                            return false;
                    }
                    argtypes[i] = anyc_actuals.anyrange_type;
                }
                break;
            case ANYCOMPATIBLEMULTIRANGEOID:
                if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE)
                {
                    have_polymorphic_result = true;
                    have_anycompatible_multirange_result = true;
                }
                else
                {
                    if (!OidIsValid(anyc_actuals.anymultirange_type))
                    {
                        anyc_actuals.anymultirange_type =
                            get_call_expr_argtype(call_expr, inargno);
                        if (!OidIsValid(anyc_actuals.anymultirange_type))
                            return false;
                    }
                    argtypes[i] = anyc_actuals.anymultirange_type;
                }
                break;
            default:
                break;
        }
        if (argmode != PROARGMODE_OUT && argmode != PROARGMODE_TABLE)
            inargno++;
    }
 
    /* Done? */
    if (!have_polymorphic_result)
        return true;
 
    /* If needed, deduce one polymorphic type from others */
    if (have_anyelement_result && !OidIsValid(poly_actuals.anyelement_type))
        resolve_anyelement_from_others(&poly_actuals);
 
    if (have_anyarray_result && !OidIsValid(poly_actuals.anyarray_type))
        resolve_anyarray_from_others(&poly_actuals);
 
    if (have_anyrange_result && !OidIsValid(poly_actuals.anyrange_type))
        resolve_anyrange_from_others(&poly_actuals);
 
    if (have_anymultirange_result && !OidIsValid(poly_actuals.anymultirange_type))
        resolve_anymultirange_from_others(&poly_actuals);
 
    if (have_anycompatible_result && !OidIsValid(anyc_actuals.anyelement_type))
        resolve_anyelement_from_others(&anyc_actuals);
 
    if (have_anycompatible_array_result && !OidIsValid(anyc_actuals.anyarray_type))
        resolve_anyarray_from_others(&anyc_actuals);
 
    if (have_anycompatible_range_result && !OidIsValid(anyc_actuals.anyrange_type))
        resolve_anyrange_from_others(&anyc_actuals);
 
    if (have_anycompatible_multirange_result && !OidIsValid(anyc_actuals.anymultirange_type))
        resolve_anymultirange_from_others(&anyc_actuals);
 
    /* And finally replace the output column types as needed */
    for (i = 0; i < numargs; i++)
    {
        switch (argtypes[i])
        {
            case ANYELEMENTOID:
            case ANYNONARRAYOID:
            case ANYENUMOID:
                argtypes[i] = poly_actuals.anyelement_type;
                break;
            case ANYARRAYOID:
                argtypes[i] = poly_actuals.anyarray_type;
                break;
            case ANYRANGEOID:
                argtypes[i] = poly_actuals.anyrange_type;
                break;
            case ANYMULTIRANGEOID:
                argtypes[i] = poly_actuals.anymultirange_type;
                break;
            case ANYCOMPATIBLEOID:
            case ANYCOMPATIBLENONARRAYOID:
                argtypes[i] = anyc_actuals.anyelement_type;
                break;
            case ANYCOMPATIBLEARRAYOID:
                argtypes[i] = anyc_actuals.anyarray_type;
                break;
            case ANYCOMPATIBLERANGEOID:
                argtypes[i] = anyc_actuals.anyrange_type;
                break;
            case ANYCOMPATIBLEMULTIRANGEOID:
                argtypes[i] = anyc_actuals.anymultirange_type;
                break;
            default:
                break;
        }
    }
 
    return true;
}

References polymorphic_actuals::anyarray_type, polymorphic_actuals::anyelement_type, polymorphic_actuals::anymultirange_type, polymorphic_actuals::anyrange_type, get_call_expr_argtype(), i, OidIsValid, resolve_anyarray_from_others(), resolve_anyelement_from_others(), resolve_anymultirange_from_others(), and resolve_anyrange_from_others().

Referenced by plpgsql_resolve_polymorphic_argtypes().

TupleDescGetAttInMetadata()

AttInMetadata* TupleDescGetAttInMetadata

(

TupleDesc

tupdesc

)

Definition at line 2086 of file execTuples.c.

{
    int         natts = tupdesc->natts;
    int         i;
    Oid         atttypeid;
    Oid         attinfuncid;
    FmgrInfo   *attinfuncinfo;
    Oid        *attioparams;
    int32      *atttypmods;
    AttInMetadata *attinmeta;
 
    attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));
 
    /* "Bless" the tupledesc so that we can make rowtype datums with it */
    attinmeta->tupdesc = BlessTupleDesc(tupdesc);
 
    /*
     * Gather info needed later to call the "in" function for each attribute
     */
    attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
    attioparams = (Oid *) palloc0(natts * sizeof(Oid));
    atttypmods = (int32 *) palloc0(natts * sizeof(int32));
 
    for (i = 0; i < natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
 
        /* Ignore dropped attributes */
        if (!att->attisdropped)
        {
            atttypeid = att->atttypid;
            getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
            fmgr_info(attinfuncid, &attinfuncinfo[i]);
            atttypmods[i] = att->atttypmod;
        }
    }
    attinmeta->attinfuncs = attinfuncinfo;
    attinmeta->attioparams = attioparams;
    attinmeta->atttypmods = atttypmods;
 
    return attinmeta;
}

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, BlessTupleDesc(), fmgr_info(), getTypeInputInfo(), i, TupleDescData::natts, palloc(), palloc0(), AttInMetadata::tupdesc, and TupleDescAttr.

Referenced by bt_metap(), bt_multi_page_stats(), bt_page_stats_internal(), build_pgstattuple_type(), connectby_text(), connectby_text_serial(), create_foreign_modify(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), hash_page_items(), libpqrcv_processTuples(), materializeResult(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pg_stats_ext_mcvlist_items(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), pltcl_func_handler(), pltcl_init_tuple_store(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignScan(), prs_setup_firstcall(), show_all_settings(), storeRow(), ts_setup_firstcall(), tt_setup_firstcall(), and xpath_table().

TypeGetTupleDesc()

TupleDesc TypeGetTupleDesc	(	Oid	typeoid,
		List *	colaliases
	)

Definition at line 1895 of file funcapi.c.

{
    Oid         base_typeoid;
    TypeFuncClass functypclass = get_type_func_class(typeoid, &base_typeoid);
    TupleDesc   tupdesc = NULL;
 
    /*
     * Build a suitable tupledesc representing the output rows.  We
     * intentionally do not support TYPEFUNC_COMPOSITE_DOMAIN here, as it's
     * unlikely that legacy callers of this obsolete function would be
     * prepared to apply domain constraints.
     */
    if (functypclass == TYPEFUNC_COMPOSITE)
    {
        /* Composite data type, e.g. a table's row type */
        tupdesc = lookup_rowtype_tupdesc_copy(base_typeoid, -1);
 
        if (colaliases != NIL)
        {
            int         natts = tupdesc->natts;
            int         varattno;
 
            /* does the list length match the number of attributes? */
            if (list_length(colaliases) != natts)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("number of aliases does not match number of columns")));
 
            /* OK, use the aliases instead */
            for (varattno = 0; varattno < natts; varattno++)
            {
                char       *label = strVal(list_nth(colaliases, varattno));
                Form_pg_attribute attr = TupleDescAttr(tupdesc, varattno);
 
                if (label != NULL)
                    namestrcpy(&(attr->attname), label);
            }
 
            /* The tuple type is now an anonymous record type */
            tupdesc->tdtypeid = RECORDOID;
            tupdesc->tdtypmod = -1;
        }
    }
    else if (functypclass == TYPEFUNC_SCALAR)
    {
        /* Base data type, i.e. scalar */
        char       *attname;
 
        /* the alias list is required for base types */
        if (colaliases == NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("no column alias was provided")));
 
        /* the alias list length must be 1 */
        if (list_length(colaliases) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("number of aliases does not match number of columns")));
 
        /* OK, get the column alias */
        attname = strVal(linitial(colaliases));
 
        tupdesc = CreateTemplateTupleDesc(1);
        TupleDescInitEntry(tupdesc,
                           (AttrNumber) 1,
                           attname,
                           typeoid,
                           -1,
                           0);
    }
    else if (functypclass == TYPEFUNC_RECORD)
    {
        /* XXX can't support this because typmod wasn't passed in ... */
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("could not determine row description for function returning record")));
    }
    else
    {
        /* crummy error message, but parser should have caught this */
        elog(ERROR, "function in FROM has unsupported return type");
    }
 
    return tupdesc;
}

References attname, CreateTemplateTupleDesc(), elog(), ereport, errcode(), errmsg(), ERROR, get_type_func_class(), label, linitial, list_length(), list_nth(), lookup_rowtype_tupdesc_copy(), namestrcpy(), TupleDescData::natts, NIL, strVal, TupleDescData::tdtypeid, TupleDescData::tdtypmod, TupleDescAttr, TupleDescInitEntry(), TYPEFUNC_COMPOSITE, TYPEFUNC_RECORD, and TYPEFUNC_SCALAR.