misc.c File Reference

#include "postgres.h"
#include <sys/file.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <math.h>
#include <unistd.h>
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_type.h"
#include "catalog/system_fk_info.h"
#include "commands/tablespace.h"
#include "common/keywords.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "parser/parse_type.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "postmaster/syslogger.h"
#include "rewrite/rewriteHandler.h"
#include "storage/fd.h"
#include "storage/latch.h"
#include "tcop/tcopprot.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/ruleutils.h"
#include "utils/syscache.h"
#include "utils/timestamp.h"

Include dependency graph for misc.c:

Go to the source code of this file.

Data Structures
struct	ValidIOData

Macros
#define	REQ_EVENTS   ((1 << CMD_UPDATE) | (1 << CMD_DELETE))

Typedefs
typedef struct ValidIOData	ValidIOData

Functions
static bool	pg_input_is_valid_common (FunctionCallInfo fcinfo, text *txt, text *typname, ErrorSaveContext *escontext)
static bool	count_nulls (FunctionCallInfo fcinfo, int32 *nargs, int32 *nulls)
Datum	pg_num_nulls (PG_FUNCTION_ARGS)
Datum	pg_num_nonnulls (PG_FUNCTION_ARGS)
Datum	current_database (PG_FUNCTION_ARGS)
Datum	current_query (PG_FUNCTION_ARGS)
Datum	pg_tablespace_databases (PG_FUNCTION_ARGS)
Datum	pg_tablespace_location (PG_FUNCTION_ARGS)
Datum	pg_sleep (PG_FUNCTION_ARGS)
Datum	pg_get_keywords (PG_FUNCTION_ARGS)
Datum	pg_get_catalog_foreign_keys (PG_FUNCTION_ARGS)
Datum	pg_typeof (PG_FUNCTION_ARGS)
Datum	pg_basetype (PG_FUNCTION_ARGS)
Datum	pg_collation_for (PG_FUNCTION_ARGS)
Datum	pg_relation_is_updatable (PG_FUNCTION_ARGS)
Datum	pg_column_is_updatable (PG_FUNCTION_ARGS)
Datum	pg_input_is_valid (PG_FUNCTION_ARGS)
Datum	pg_input_error_info (PG_FUNCTION_ARGS)
static bool	is_ident_start (unsigned char c)
static bool	is_ident_cont (unsigned char c)
Datum	parse_ident (PG_FUNCTION_ARGS)
Datum	pg_current_logfile (PG_FUNCTION_ARGS)
Datum	pg_current_logfile_1arg (PG_FUNCTION_ARGS)
Datum	pg_get_replica_identity_index (PG_FUNCTION_ARGS)
Datum	any_value_transfn (PG_FUNCTION_ARGS)

Macro Definition Documentation

REQ_EVENTS

#define REQ_EVENTS   ((1 << CMD_UPDATE) | (1 << CMD_DELETE))

Typedef Documentation

ValidIOData

typedef struct ValidIOData ValidIOData

Function Documentation

any_value_transfn()

Datum any_value_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1131 of file misc.c.

{
    PG_RETURN_DATUM(PG_GETARG_DATUM(0));
}

References PG_GETARG_DATUM, and PG_RETURN_DATUM.

count_nulls()

static bool count_nulls ( FunctionCallInfo  fcinfo, int32 *  nargs, int32 *  nulls  )

static

Definition at line 75 of file misc.c.

{
    int32       count = 0;
    int         i;
 
    /* Did we get a VARIADIC array argument, or separate arguments? */
    if (get_fn_expr_variadic(fcinfo->flinfo))
    {
        ArrayType  *arr;
        int         ndims,
                    nitems,
                   *dims;
        bits8      *bitmap;
 
        Assert(PG_NARGS() == 1);
 
        /*
         * If we get a null as VARIADIC array argument, we can't say anything
         * useful about the number of elements, so return NULL.  This behavior
         * is consistent with other variadic functions - see concat_internal.
         */
        if (PG_ARGISNULL(0))
            return false;
 
        /*
         * Non-null argument had better be an array.  We assume that any call
         * context that could let get_fn_expr_variadic return true will have
         * checked that a VARIADIC-labeled parameter actually is an array.  So
         * it should be okay to just Assert that it's an array rather than
         * doing a full-fledged error check.
         */
        Assert(OidIsValid(get_base_element_type(get_fn_expr_argtype(fcinfo->flinfo, 0))));
 
        /* OK, safe to fetch the array value */
        arr = PG_GETARG_ARRAYTYPE_P(0);
 
        /* Count the array elements */
        ndims = ARR_NDIM(arr);
        dims = ARR_DIMS(arr);
        nitems = ArrayGetNItems(ndims, dims);
 
        /* Count those that are NULL */
        bitmap = ARR_NULLBITMAP(arr);
        if (bitmap)
        {
            int         bitmask = 1;
 
            for (i = 0; i < nitems; i++)
            {
                if ((*bitmap & bitmask) == 0)
                    count++;
 
                bitmask <<= 1;
                if (bitmask == 0x100)
                {
                    bitmap++;
                    bitmask = 1;
                }
            }
        }
 
        *nargs = nitems;
        *nulls = count;
    }
    else
    {
        /* Separate arguments, so just count 'em */
        for (i = 0; i < PG_NARGS(); i++)
        {
            if (PG_ARGISNULL(i))
                count++;
        }
 
        *nargs = PG_NARGS();
        *nulls = count;
    }
 
    return true;
}

References ARR_DIMS, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert(), FunctionCallInfoBaseData::flinfo, get_base_element_type(), get_fn_expr_argtype(), get_fn_expr_variadic(), i, nitems, OidIsValid, PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, and PG_NARGS.

Referenced by pg_num_nonnulls(), and pg_num_nulls().

current_database()

Datum current_database

(

PG_FUNCTION_ARGS

)

Definition at line 194 of file misc.c.

{
    Name        db;
 
    db = (Name) palloc(NAMEDATALEN);
 
    namestrcpy(db, get_database_name(MyDatabaseId));
    PG_RETURN_NAME(db);
}

References get_database_name(), MyDatabaseId, NAMEDATALEN, namestrcpy(), palloc(), and PG_RETURN_NAME.

Referenced by ExecEvalSQLValueFunction().

current_query()

Datum current_query

(

PG_FUNCTION_ARGS

)

Definition at line 211 of file misc.c.

{
    /* there is no easy way to access the more concise 'query_string' */
    if (debug_query_string)
        PG_RETURN_TEXT_P(cstring_to_text(debug_query_string));
    else
        PG_RETURN_NULL();
}

References cstring_to_text(), debug_query_string, PG_RETURN_NULL, and PG_RETURN_TEXT_P.

Referenced by dblink_current_query().

is_ident_cont()

static bool is_ident_cont ( unsigned char  c )

static

Definition at line 856 of file misc.c.

{
    /* Can be digit or dollar sign ... */
    if ((c >= '0' && c <= '9') || c == '$')
        return true;
    /* ... or an identifier start character */
    return is_ident_start(c);
}

References is_ident_start().

Referenced by parse_ident().

is_ident_start()

static bool is_ident_start ( unsigned char  c )

static

Definition at line 838 of file misc.c.

{
    /* Underscores and ASCII letters are OK */
    if (c == '_')
        return true;
    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
        return true;
    /* Any high-bit-set character is OK (might be part of a multibyte char) */
    if (IS_HIGHBIT_SET(c))
        return true;
    return false;
}

References IS_HIGHBIT_SET.

Referenced by is_ident_cont(), and parse_ident().

parse_ident()

Datum parse_ident

(

PG_FUNCTION_ARGS

)

Definition at line 871 of file misc.c.

{
    text       *qualname = PG_GETARG_TEXT_PP(0);
    bool        strict = PG_GETARG_BOOL(1);
    char       *qualname_str = text_to_cstring(qualname);
    ArrayBuildState *astate = NULL;
    char       *nextp;
    bool        after_dot = false;
 
    /*
     * The code below scribbles on qualname_str in some cases, so we should
     * reconvert qualname if we need to show the original string in error
     * messages.
     */
    nextp = qualname_str;
 
    /* skip leading whitespace */
    while (scanner_isspace(*nextp))
        nextp++;
 
    for (;;)
    {
        char       *curname;
        bool        missing_ident = true;
 
        if (*nextp == '"')
        {
            char       *endp;
 
            curname = nextp + 1;
            for (;;)
            {
                endp = strchr(nextp + 1, '"');
                if (endp == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("string is not a valid identifier: \"%s\"",
                                    text_to_cstring(qualname)),
                             errdetail("String has unclosed double quotes.")));
                if (endp[1] != '"')
                    break;
                memmove(endp, endp + 1, strlen(endp));
                nextp = endp;
            }
            nextp = endp + 1;
            *endp = '\0';
 
            if (endp - curname == 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("string is not a valid identifier: \"%s\"",
                                text_to_cstring(qualname)),
                         errdetail("Quoted identifier must not be empty.")));
 
            astate = accumArrayResult(astate, CStringGetTextDatum(curname),
                                      false, TEXTOID, CurrentMemoryContext);
            missing_ident = false;
        }
        else if (is_ident_start((unsigned char) *nextp))
        {
            char       *downname;
            int         len;
            text       *part;
 
            curname = nextp++;
            while (is_ident_cont((unsigned char) *nextp))
                nextp++;
 
            len = nextp - curname;
 
            /*
             * We don't implicitly truncate identifiers. This is useful for
             * allowing the user to check for specific parts of the identifier
             * being too long. It's easy enough for the user to get the
             * truncated names by casting our output to name[].
             */
            downname = downcase_identifier(curname, len, false, false);
            part = cstring_to_text_with_len(downname, len);
            astate = accumArrayResult(astate, PointerGetDatum(part), false,
                                      TEXTOID, CurrentMemoryContext);
            missing_ident = false;
        }
 
        if (missing_ident)
        {
            /* Different error messages based on where we failed. */
            if (*nextp == '.')
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("string is not a valid identifier: \"%s\"",
                                text_to_cstring(qualname)),
                         errdetail("No valid identifier before \".\".")));
            else if (after_dot)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("string is not a valid identifier: \"%s\"",
                                text_to_cstring(qualname)),
                         errdetail("No valid identifier after \".\".")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("string is not a valid identifier: \"%s\"",
                                text_to_cstring(qualname))));
        }
 
        while (scanner_isspace(*nextp))
            nextp++;
 
        if (*nextp == '.')
        {
            after_dot = true;
            nextp++;
            while (scanner_isspace(*nextp))
                nextp++;
        }
        else if (*nextp == '\0')
        {
            break;
        }
        else
        {
            if (strict)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("string is not a valid identifier: \"%s\"",
                                text_to_cstring(qualname))));
            break;
        }
    }
 
    PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
}

References accumArrayResult(), cstring_to_text_with_len(), CStringGetTextDatum, CurrentMemoryContext, downcase_identifier(), ereport, errcode(), errdetail(), errmsg(), ERROR, is_ident_cont(), is_ident_start(), len, makeArrayResult(), PG_GETARG_BOOL, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PointerGetDatum(), scanner_isspace(), and text_to_cstring().

pg_basetype()

Datum pg_basetype

(

PG_FUNCTION_ARGS

)

Definition at line 593 of file misc.c.

{
    Oid         typid = PG_GETARG_OID(0);
 
    /*
     * We loop to find the bottom base type in a stack of domains.
     */
    for (;;)
    {
        HeapTuple   tup;
        Form_pg_type typTup;
 
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
        if (!HeapTupleIsValid(tup))
            PG_RETURN_NULL();   /* return NULL for bogus OID */
        typTup = (Form_pg_type) GETSTRUCT(tup);
        if (typTup->typtype != TYPTYPE_DOMAIN)
        {
            /* Not a domain, so done */
            ReleaseSysCache(tup);
            break;
        }
 
        typid = typTup->typbasetype;
        ReleaseSysCache(tup);
    }
 
    PG_RETURN_OID(typid);
}

References GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_OID, ReleaseSysCache(), and SearchSysCache1().

pg_collation_for()

Datum pg_collation_for

(

PG_FUNCTION_ARGS

)

Definition at line 629 of file misc.c.

{
    Oid         typeid;
    Oid         collid;
 
    typeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (!typeid)
        PG_RETURN_NULL();
    if (!type_is_collatable(typeid) && typeid != UNKNOWNOID)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("collations are not supported by type %s",
                        format_type_be(typeid))));
 
    collid = PG_GET_COLLATION();
    if (!collid)
        PG_RETURN_NULL();
    PG_RETURN_TEXT_P(cstring_to_text(generate_collation_name(collid)));
}

References collid, cstring_to_text(), ereport, errcode(), errmsg(), ERROR, format_type_be(), generate_collation_name(), get_fn_expr_argtype(), PG_GET_COLLATION, PG_RETURN_NULL, PG_RETURN_TEXT_P, and type_is_collatable().

pg_column_is_updatable()

Datum pg_column_is_updatable

(

PG_FUNCTION_ARGS

)

Definition at line 675 of file misc.c.

{
    Oid         reloid = PG_GETARG_OID(0);
    AttrNumber  attnum = PG_GETARG_INT16(1);
    AttrNumber  col = attnum - FirstLowInvalidHeapAttributeNumber;
    bool        include_triggers = PG_GETARG_BOOL(2);
    int         events;
 
    /* System columns are never updatable */
    if (attnum <= 0)
        PG_RETURN_BOOL(false);
 
    events = relation_is_updatable(reloid, NIL, include_triggers,
                                   bms_make_singleton(col));
 
    /* We require both updatability and deletability of the relation */
#define REQ_EVENTS ((1 << CMD_UPDATE) | (1 << CMD_DELETE))
 
    PG_RETURN_BOOL((events & REQ_EVENTS) == REQ_EVENTS);
}

References attnum, bms_make_singleton(), FirstLowInvalidHeapAttributeNumber, NIL, PG_GETARG_BOOL, PG_GETARG_INT16, PG_GETARG_OID, PG_RETURN_BOOL, relation_is_updatable(), and REQ_EVENTS.

pg_current_logfile()

Datum pg_current_logfile

(

PG_FUNCTION_ARGS

)

Definition at line 1010 of file misc.c.

{
    FILE       *fd;
    char        lbuffer[MAXPGPATH];
    char       *logfmt;
 
    /* The log format parameter is optional */
    if (PG_NARGS() == 0 || PG_ARGISNULL(0))
        logfmt = NULL;
    else
    {
        logfmt = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
        if (strcmp(logfmt, "stderr") != 0 &&
            strcmp(logfmt, "csvlog") != 0 &&
            strcmp(logfmt, "jsonlog") != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("log format \"%s\" is not supported", logfmt),
                     errhint("The supported log formats are \"stderr\", \"csvlog\", and \"jsonlog\".")));
    }
 
    fd = AllocateFile(LOG_METAINFO_DATAFILE, "r");
    if (fd == NULL)
    {
        if (errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m",
                            LOG_METAINFO_DATAFILE)));
        PG_RETURN_NULL();
    }
 
#ifdef WIN32
    /* syslogger.c writes CRLF line endings on Windows */
    _setmode(_fileno(fd), _O_TEXT);
#endif
 
    /*
     * Read the file to gather current log filename(s) registered by the
     * syslogger.
     */
    while (fgets(lbuffer, sizeof(lbuffer), fd) != NULL)
    {
        char       *log_format;
        char       *log_filepath;
        char       *nlpos;
 
        /* Extract log format and log file path from the line. */
        log_format = lbuffer;
        log_filepath = strchr(lbuffer, ' ');
        if (log_filepath == NULL)
        {
            /* Uh oh.  No space found, so file content is corrupted. */
            elog(ERROR,
                 "missing space character in \"%s\"", LOG_METAINFO_DATAFILE);
            break;
        }
 
        *log_filepath = '\0';
        log_filepath++;
        nlpos = strchr(log_filepath, '\n');
        if (nlpos == NULL)
        {
            /* Uh oh.  No newline found, so file content is corrupted. */
            elog(ERROR,
                 "missing newline character in \"%s\"", LOG_METAINFO_DATAFILE);
            break;
        }
        *nlpos = '\0';
 
        if (logfmt == NULL || strcmp(logfmt, log_format) == 0)
        {
            FreeFile(fd);
            PG_RETURN_TEXT_P(cstring_to_text(log_filepath));
        }
    }
 
    /* Close the current log filename file. */
    FreeFile(fd);
 
    PG_RETURN_NULL();
}

References AllocateFile(), cstring_to_text(), elog, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, fd(), FreeFile(), LOG_METAINFO_DATAFILE, MAXPGPATH, PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_NARGS, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

Referenced by pg_current_logfile_1arg().

pg_current_logfile_1arg()

Datum pg_current_logfile_1arg

(

PG_FUNCTION_ARGS

)

Definition at line 1102 of file misc.c.

{
    return pg_current_logfile(fcinfo);
}

References pg_current_logfile().

pg_get_catalog_foreign_keys()

Datum pg_get_catalog_foreign_keys

(

PG_FUNCTION_ARGS

)

Definition at line 506 of file misc.c.

{
    FuncCallContext *funcctx;
    FmgrInfo   *arrayinp;
 
    if (SRF_IS_FIRSTCALL())
    {
        MemoryContext oldcontext;
        TupleDesc   tupdesc;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
        funcctx->tuple_desc = BlessTupleDesc(tupdesc);
 
        /*
         * We use array_in to convert the C strings in sys_fk_relationships[]
         * to text arrays.  But we cannot use DirectFunctionCallN to call
         * array_in, and it wouldn't be very efficient if we could.  Fill an
         * FmgrInfo to use for the call.
         */
        arrayinp = (FmgrInfo *) palloc(sizeof(FmgrInfo));
        fmgr_info(F_ARRAY_IN, arrayinp);
        funcctx->user_fctx = arrayinp;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    arrayinp = (FmgrInfo *) funcctx->user_fctx;
 
    if (funcctx->call_cntr < lengthof(sys_fk_relationships))
    {
        const SysFKRelationship *fkrel = &sys_fk_relationships[funcctx->call_cntr];
        Datum       values[6];
        bool        nulls[6];
        HeapTuple   tuple;
 
        memset(nulls, false, sizeof(nulls));
 
        values[0] = ObjectIdGetDatum(fkrel->fk_table);
        values[1] = FunctionCall3(arrayinp,
                                  CStringGetDatum(fkrel->fk_columns),
                                  ObjectIdGetDatum(TEXTOID),
                                  Int32GetDatum(-1));
        values[2] = ObjectIdGetDatum(fkrel->pk_table);
        values[3] = FunctionCall3(arrayinp,
                                  CStringGetDatum(fkrel->pk_columns),
                                  ObjectIdGetDatum(TEXTOID),
                                  Int32GetDatum(-1));
        values[4] = BoolGetDatum(fkrel->is_array);
        values[5] = BoolGetDatum(fkrel->is_opt);
 
        tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
 
        SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
    }
 
    SRF_RETURN_DONE(funcctx);
}

References BlessTupleDesc(), BoolGetDatum(), FuncCallContext::call_cntr, CStringGetDatum(), elog, ERROR, fmgr_info(), FunctionCall3, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), if(), Int32GetDatum(), lengthof, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, ObjectIdGetDatum(), palloc(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::tuple_desc, TYPEFUNC_COMPOSITE, FuncCallContext::user_fctx, and values.

pg_get_keywords()

Datum pg_get_keywords

(

PG_FUNCTION_ARGS

)

Definition at line 428 of file misc.c.

{
    FuncCallContext *funcctx;
 
    if (SRF_IS_FIRSTCALL())
    {
        MemoryContext oldcontext;
        TupleDesc   tupdesc;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
            elog(ERROR, "return type must be a row type");
        funcctx->tuple_desc = tupdesc;
        funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
 
    if (funcctx->call_cntr < ScanKeywords.num_keywords)
    {
        char       *values[5];
        HeapTuple   tuple;
 
        /* cast-away-const is ugly but alternatives aren't much better */
        values[0] = unconstify(char *,
                               GetScanKeyword(funcctx->call_cntr,
                                              &ScanKeywords));
 
        switch (ScanKeywordCategories[funcctx->call_cntr])
        {
            case UNRESERVED_KEYWORD:
                values[1] = "U";
                values[3] = _("unreserved");
                break;
            case COL_NAME_KEYWORD:
                values[1] = "C";
                values[3] = _("unreserved (cannot be function or type name)");
                break;
            case TYPE_FUNC_NAME_KEYWORD:
                values[1] = "T";
                values[3] = _("reserved (can be function or type name)");
                break;
            case RESERVED_KEYWORD:
                values[1] = "R";
                values[3] = _("reserved");
                break;
            default:            /* shouldn't be possible */
                values[1] = NULL;
                values[3] = NULL;
                break;
        }
 
        if (ScanKeywordBareLabel[funcctx->call_cntr])
        {
            values[2] = "true";
            values[4] = _("can be bare label");
        }
        else
        {
            values[2] = "false";
            values[4] = _("requires AS");
        }
 
        tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
 
        SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
    }
 
    SRF_RETURN_DONE(funcctx);
}

References _, FuncCallContext::attinmeta, BuildTupleFromCStrings(), FuncCallContext::call_cntr, COL_NAME_KEYWORD, elog, ERROR, get_call_result_type(), GetScanKeyword(), HeapTupleGetDatum(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, ScanKeywordList::num_keywords, RESERVED_KEYWORD, ScanKeywordBareLabel, ScanKeywordCategories, ScanKeywords, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::tuple_desc, TupleDescGetAttInMetadata(), TYPE_FUNC_NAME_KEYWORD, TYPEFUNC_COMPOSITE, unconstify, UNRESERVED_KEYWORD, and values.

pg_get_replica_identity_index()

Datum pg_get_replica_identity_index

(

PG_FUNCTION_ARGS

)

Definition at line 1111 of file misc.c.

{
    Oid         reloid = PG_GETARG_OID(0);
    Oid         idxoid;
    Relation    rel;
 
    rel = table_open(reloid, AccessShareLock);
    idxoid = RelationGetReplicaIndex(rel);
    table_close(rel, AccessShareLock);
 
    if (OidIsValid(idxoid))
        PG_RETURN_OID(idxoid);
    else
        PG_RETURN_NULL();
}

References AccessShareLock, OidIsValid, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_OID, RelationGetReplicaIndex(), table_close(), and table_open().

pg_input_error_info()

Datum pg_input_error_info

(

PG_FUNCTION_ARGS

)

Definition at line 726 of file misc.c.

{
    text       *txt = PG_GETARG_TEXT_PP(0);
    text       *typname = PG_GETARG_TEXT_PP(1);
    ErrorSaveContext escontext = {T_ErrorSaveContext};
    TupleDesc   tupdesc;
    Datum       values[4];
    bool        isnull[4];
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    /* Enable details_wanted */
    escontext.details_wanted = true;
 
    if (pg_input_is_valid_common(fcinfo, txt, typname,
                                 &escontext))
        memset(isnull, true, sizeof(isnull));
    else
    {
        char       *sqlstate;
 
        Assert(escontext.error_occurred);
        Assert(escontext.error_data != NULL);
        Assert(escontext.error_data->message != NULL);
 
        memset(isnull, false, sizeof(isnull));
 
        values[0] = CStringGetTextDatum(escontext.error_data->message);
 
        if (escontext.error_data->detail != NULL)
            values[1] = CStringGetTextDatum(escontext.error_data->detail);
        else
            isnull[1] = true;
 
        if (escontext.error_data->hint != NULL)
            values[2] = CStringGetTextDatum(escontext.error_data->hint);
        else
            isnull[2] = true;
 
        sqlstate = unpack_sql_state(escontext.error_data->sqlerrcode);
        values[3] = CStringGetTextDatum(sqlstate);
    }
 
    return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
}

References Assert(), CStringGetTextDatum, ErrorData::detail, ErrorSaveContext::details_wanted, elog, ERROR, ErrorSaveContext::error_data, ErrorSaveContext::error_occurred, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), ErrorData::hint, ErrorData::message, PG_GETARG_TEXT_PP, pg_input_is_valid_common(), ErrorData::sqlerrcode, TYPEFUNC_COMPOSITE, typname, unpack_sql_state(), and values.

pg_input_is_valid()

Datum pg_input_is_valid

(

PG_FUNCTION_ARGS

)

Definition at line 706 of file misc.c.

{
    text       *txt = PG_GETARG_TEXT_PP(0);
    text       *typname = PG_GETARG_TEXT_PP(1);
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    PG_RETURN_BOOL(pg_input_is_valid_common(fcinfo, txt, typname,
                                            &escontext));
}

References PG_GETARG_TEXT_PP, pg_input_is_valid_common(), PG_RETURN_BOOL, and typname.

pg_input_is_valid_common()

static bool pg_input_is_valid_common ( FunctionCallInfo  fcinfo, text *  txt, text *  typname, ErrorSaveContext *  escontext  )

static

Definition at line 775 of file misc.c.

{
    char       *str = text_to_cstring(txt);
    ValidIOData *my_extra;
    Datum       converted;
 
    /*
     * We arrange to look up the needed I/O info just once per series of
     * calls, assuming the data type doesn't change underneath us.
     */
    my_extra = (ValidIOData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               sizeof(ValidIOData));
        my_extra = (ValidIOData *) fcinfo->flinfo->fn_extra;
        my_extra->typoid = InvalidOid;
        /* Detect whether typname argument is constant. */
        my_extra->typname_constant = get_fn_expr_arg_stable(fcinfo->flinfo, 1);
    }
 
    /*
     * If the typname argument is constant, we only need to parse it the first
     * time through.
     */
    if (my_extra->typoid == InvalidOid || !my_extra->typname_constant)
    {
        char       *typnamestr = text_to_cstring(typname);
        Oid         typoid;
 
        /* Parse type-name argument to obtain type OID and encoded typmod. */
        (void) parseTypeString(typnamestr, &typoid, &my_extra->typmod, NULL);
 
        /* Update type-specific info if typoid changed. */
        if (my_extra->typoid != typoid)
        {
            getTypeInputInfo(typoid,
                             &my_extra->typiofunc,
                             &my_extra->typioparam);
            fmgr_info_cxt(my_extra->typiofunc, &my_extra->inputproc,
                          fcinfo->flinfo->fn_mcxt);
            my_extra->typoid = typoid;
        }
    }
 
    /* Now we can try to perform the conversion. */
    return InputFunctionCallSafe(&my_extra->inputproc,
                                 str,
                                 my_extra->typioparam,
                                 my_extra->typmod,
                                 (Node *) escontext,
                                 &converted);
}

References FunctionCallInfoBaseData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_fn_expr_arg_stable(), getTypeInputInfo(), if(), InputFunctionCallSafe(), ValidIOData::inputproc, InvalidOid, MemoryContextAlloc(), parseTypeString(), str, text_to_cstring(), ValidIOData::typiofunc, ValidIOData::typioparam, ValidIOData::typmod, typname, ValidIOData::typname_constant, and ValidIOData::typoid.

Referenced by pg_input_error_info(), and pg_input_is_valid().

pg_num_nonnulls()

Datum pg_num_nonnulls

(

PG_FUNCTION_ARGS

)

Definition at line 177 of file misc.c.

{
    int32       nargs,
                nulls;
 
    if (!count_nulls(fcinfo, &nargs, &nulls))
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(nargs - nulls);
}

References count_nulls(), PG_RETURN_INT32, and PG_RETURN_NULL.

pg_num_nulls()

Datum pg_num_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 161 of file misc.c.

{
    int32       nargs,
                nulls;
 
    if (!count_nulls(fcinfo, &nargs, &nulls))
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(nulls);
}

References count_nulls(), PG_RETURN_INT32, and PG_RETURN_NULL.

pg_relation_is_updatable()

Datum pg_relation_is_updatable

(

PG_FUNCTION_ARGS

)

Definition at line 658 of file misc.c.

{
    Oid         reloid = PG_GETARG_OID(0);
    bool        include_triggers = PG_GETARG_BOOL(1);
 
    PG_RETURN_INT32(relation_is_updatable(reloid, NIL, include_triggers, NULL));
}

References NIL, PG_GETARG_BOOL, PG_GETARG_OID, PG_RETURN_INT32, and relation_is_updatable().

pg_sleep()

Datum pg_sleep

(

PG_FUNCTION_ARGS

)

Definition at line 369 of file misc.c.

{
    float8      secs = PG_GETARG_FLOAT8(0);
    int64       usecs;
    TimestampTz endtime;
 
    /*
     * Convert the delay to int64 microseconds, rounding up any fraction, and
     * silently limiting it to PG_INT64_MAX/2 microseconds (about 150K years)
     * to ensure the computation of endtime won't overflow.  Historically
     * we've treated NaN as "no wait", not an error, so keep that behavior.
     */
    if (isnan(secs) || secs <= 0.0)
        PG_RETURN_VOID();
    secs *= USECS_PER_SEC;      /* we assume overflow will produce +Inf */
    secs = ceil(secs);          /* round up any fractional microsecond */
    usecs = (int64) Min(secs, (float8) (PG_INT64_MAX / 2));
 
    /*
     * We sleep using WaitLatch, to ensure that we'll wake up promptly if an
     * important signal (such as SIGALRM or SIGINT) arrives.  Because
     * WaitLatch's upper limit of delay is INT_MAX milliseconds, and the user
     * might ask for more than that, we sleep for at most 10 minutes and then
     * loop.
     *
     * By computing the intended stop time initially, we avoid accumulation of
     * extra delay across multiple sleeps.  This also ensures we won't delay
     * less than the specified time when WaitLatch is terminated early by a
     * non-query-canceling signal such as SIGHUP.
     */
    endtime = GetCurrentTimestamp() + usecs;
 
    for (;;)
    {
        TimestampTz delay;
        long        delay_ms;
 
        CHECK_FOR_INTERRUPTS();
 
        delay = endtime - GetCurrentTimestamp();
        if (delay >= 600 * USECS_PER_SEC)
            delay_ms = 600000;
        else if (delay > 0)
            delay_ms = (long) ((delay + 999) / 1000);
        else
            break;
 
        (void) WaitLatch(MyLatch,
                         WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                         delay_ms,
                         WAIT_EVENT_PG_SLEEP);
        ResetLatch(MyLatch);
    }
 
    PG_RETURN_VOID();
}

References CHECK_FOR_INTERRUPTS, GetCurrentTimestamp(), Min, MyLatch, PG_GETARG_FLOAT8, PG_INT64_MAX, PG_RETURN_VOID, ResetLatch(), USECS_PER_SEC, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

pg_tablespace_databases()

Datum pg_tablespace_databases

(

PG_FUNCTION_ARGS

)

Definition at line 223 of file misc.c.

{
    Oid         tablespaceOid = PG_GETARG_OID(0);
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    char       *location;
    DIR        *dirdesc;
    struct dirent *de;
 
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC);
 
    if (tablespaceOid == GLOBALTABLESPACE_OID)
    {
        ereport(WARNING,
                (errmsg("global tablespace never has databases")));
        /* return empty tuplestore */
        return (Datum) 0;
    }
 
    if (tablespaceOid == DEFAULTTABLESPACE_OID)
        location = "base";
    else
        location = psprintf("%s/%u/%s", PG_TBLSPC_DIR, tablespaceOid,
                            TABLESPACE_VERSION_DIRECTORY);
 
    dirdesc = AllocateDir(location);
 
    if (!dirdesc)
    {
        /* the only expected error is ENOENT */
        if (errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open directory \"%s\": %m",
                            location)));
        ereport(WARNING,
                (errmsg("%u is not a tablespace OID", tablespaceOid)));
        /* return empty tuplestore */
        return (Datum) 0;
    }
 
    while ((de = ReadDir(dirdesc, location)) != NULL)
    {
        Oid         datOid = atooid(de->d_name);
        char       *subdir;
        bool        isempty;
        Datum       values[1];
        bool        nulls[1];
 
        /* this test skips . and .., but is awfully weak */
        if (!datOid)
            continue;
 
        /* if database subdir is empty, don't report tablespace as used */
 
        subdir = psprintf("%s/%s", location, de->d_name);
        isempty = directory_is_empty(subdir);
        pfree(subdir);
 
        if (isempty)
            continue;           /* indeed, nothing in it */
 
        values[0] = ObjectIdGetDatum(datOid);
        nulls[0] = false;
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    FreeDir(dirdesc);
    return (Datum) 0;
}

References AllocateDir(), atooid, directory_is_empty(), ereport, errcode_for_file_access(), errmsg(), ERROR, FreeDir(), InitMaterializedSRF(), MAT_SRF_USE_EXPECTED_DESC, ObjectIdGetDatum(), pfree(), PG_GETARG_OID, PG_TBLSPC_DIR, psprintf(), ReadDir(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, TABLESPACE_VERSION_DIRECTORY, tuplestore_putvalues(), values, and WARNING.

pg_tablespace_location()

Datum pg_tablespace_location

(

PG_FUNCTION_ARGS

)

Definition at line 300 of file misc.c.

{
    Oid         tablespaceOid = PG_GETARG_OID(0);
    char        sourcepath[MAXPGPATH];
    char        targetpath[MAXPGPATH];
    int         rllen;
    struct stat st;
 
    /*
     * It's useful to apply this function to pg_class.reltablespace, wherein
     * zero means "the database's default tablespace".  So, rather than
     * throwing an error for zero, we choose to assume that's what is meant.
     */
    if (tablespaceOid == InvalidOid)
        tablespaceOid = MyDatabaseTableSpace;
 
    /*
     * Return empty string for the cluster's default tablespaces
     */
    if (tablespaceOid == DEFAULTTABLESPACE_OID ||
        tablespaceOid == GLOBALTABLESPACE_OID)
        PG_RETURN_TEXT_P(cstring_to_text(""));
 
    /*
     * Find the location of the tablespace by reading the symbolic link that
     * is in pg_tblspc/<oid>.
     */
    snprintf(sourcepath, sizeof(sourcepath), "%s/%u", PG_TBLSPC_DIR, tablespaceOid);
 
    /*
     * Before reading the link, check if the source path is a link or a
     * junction point.  Note that a directory is possible for a tablespace
     * created with allow_in_place_tablespaces enabled.  If a directory is
     * found, a relative path to the data directory is returned.
     */
    if (lstat(sourcepath, &st) < 0)
    {
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m",
                        sourcepath)));
    }
 
    if (!S_ISLNK(st.st_mode))
        PG_RETURN_TEXT_P(cstring_to_text(sourcepath));
 
    /*
     * In presence of a link or a junction point, return the path pointing to.
     */
    rllen = readlink(sourcepath, targetpath, sizeof(targetpath));
    if (rllen < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not read symbolic link \"%s\": %m",
                        sourcepath)));
    if (rllen >= sizeof(targetpath))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("symbolic link \"%s\" target is too long",
                        sourcepath)));
    targetpath[rllen] = '\0';
 
    PG_RETURN_TEXT_P(cstring_to_text(targetpath));
}

References cstring_to_text(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, InvalidOid, lstat, MAXPGPATH, MyDatabaseTableSpace, PG_GETARG_OID, PG_RETURN_TEXT_P, PG_TBLSPC_DIR, readlink, S_ISLNK, snprintf, and stat::st_mode.

pg_typeof()

Datum pg_typeof

(

PG_FUNCTION_ARGS

)

Definition at line 574 of file misc.c.

{
    PG_RETURN_OID(get_fn_expr_argtype(fcinfo->flinfo, 0));
}

References get_fn_expr_argtype(), and PG_RETURN_OID.