/*-------------------------------------------------------------------------

 *

 * misc.c

 *

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/utils/adt/misc.c

 *

 *-------------------------------------------------------------------------

 */

#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/htup_details.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 "utils/tuplestore.h"

#include "utils/wait_event.h"

/*

 * structure to cache metadata needed in pg_input_is_valid_common

 */

typedef struct ValidIOData

{

  Oid     typoid;

  int32   typmod;

  bool    typname_constant;

  Oid     typiofunc;

  Oid     typioparam;

  FmgrInfo  inputproc;

} ValidIOData;

static bool pg_input_is_valid_common(FunctionCallInfo fcinfo,

                   text *txt, text *typname,

                   ErrorSaveContext *escontext);

/*

 * Common subroutine for num_nulls() and num_nonnulls().

 * Returns true if successful, false if function should return NULL.

 * If successful, total argument count and number of nulls are

 * returned into *nargs and *nulls.

 */

static bool

count_nulls(FunctionCallInfo fcinfo,

      int32 *nargs, int32 *nulls)

{

  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;

    uint8    *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;

}

/*

 * num_nulls()

 *  Count the number of NULL arguments

 */

Datum

pg_num_nulls(PG_FUNCTION_ARGS)

{

  int32   nargs,

        nulls;

  if (!count_nulls(fcinfo, &nargs, &nulls))

    PG_RETURN_NULL();

  PG_RETURN_INT32(nulls);

}

/*

 * num_nonnulls()

 *  Count the number of non-NULL arguments

 */

Datum

pg_num_nonnulls(PG_FUNCTION_ARGS)

{

  int32   nargs,

        nulls;

  if (!count_nulls(fcinfo, &nargs, &nulls))

    PG_RETURN_NULL();

  PG_RETURN_INT32(nargs - nulls);

}

/*

 * error_on_null()

 *  Check if the input is the NULL value

 */

Datum

pg_error_on_null(PG_FUNCTION_ARGS)

{

  if (PG_ARGISNULL(0))

    ereport(ERROR,

        (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),

         errmsg("null value not allowed")));

  PG_RETURN_DATUM(PG_GETARG_DATUM(0));

}

/*

 * current_database()

 *  Expose the current database to the user

 */

Datum

current_database(PG_FUNCTION_ARGS)

{

  Name    db;

  db = (Name) palloc(NAMEDATALEN);

  namestrcpy(db, get_database_name(MyDatabaseId));

  PG_RETURN_NAME(db);

}

/*

 * current_query()

 *  Expose the current query to the user (useful in stored procedures)

 *  We might want to use ActivePortal->sourceText someday.

 */

Datum

current_query(PG_FUNCTION_ARGS)

{

  /* 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();

}

/* Function to find out which databases make use of a tablespace */

Datum

pg_tablespace_databases(PG_FUNCTION_ARGS)

{

  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;

}

/*

 * pg_tablespace_location - get location for a tablespace

 */

Datum

pg_tablespace_location(PG_FUNCTION_ARGS)

{

  Oid     tablespaceOid = PG_GETARG_OID(0);

  char     *tablespaceLoc;

  /* Get LOCATION string from its OID */

  tablespaceLoc = get_tablespace_location(tablespaceOid);

  PG_RETURN_TEXT_P(cstring_to_text(tablespaceLoc));

}

/*

 * pg_sleep - delay for N seconds

 */

Datum

pg_sleep(PG_FUNCTION_ARGS)

{

  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();

}

/* Function to return the list of grammar keywords */

Datum

pg_get_keywords(PG_FUNCTION_ARGS)

{

  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);

}

/* Function to return the list of catalog foreign key relationships */

Datum

pg_get_catalog_foreign_keys(PG_FUNCTION_ARGS)

{

  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 = palloc_object(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);

}

/*

 * Return the type of the argument.

 */

Datum

pg_typeof(PG_FUNCTION_ARGS)

{

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

}

/*

 * Return the base type of the argument.

 *    If the given type is a domain, return its base type;

 *    otherwise return the type's own OID.

 *    Return NULL if the type OID doesn't exist or points to a

 *    non-existent base type.

 *

 * This is a SQL-callable version of getBaseType().  Unlike that function,

 * we don't want to fail for a bogus type OID; this is helpful to keep race

 * conditions from turning into query failures when scanning the catalogs.

 * Hence we need our own implementation.

 */

Datum

pg_basetype(PG_FUNCTION_ARGS)

{

  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);

}

/*

 * Implementation of the COLLATE FOR expression; returns the collation

 * of the argument.

 */

Datum

pg_collation_for(PG_FUNCTION_ARGS)

{

  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)));

}

/*

 * pg_relation_is_updatable - determine which update events the specified

 * relation supports.

 *

 * This relies on relation_is_updatable() in rewriteHandler.c, which see

 * for additional information.

 */

Datum

pg_relation_is_updatable(PG_FUNCTION_ARGS)

{

  Oid     reloid = PG_GETARG_OID(0);

  bool    include_triggers = PG_GETARG_BOOL(1);

  PG_RETURN_INT32(relation_is_updatable(reloid, NIL, include_triggers, NULL));

}

/*

 * pg_column_is_updatable - determine whether a column is updatable

 *

 * This function encapsulates the decision about just what

 * information_schema.columns.is_updatable actually means.  It's not clear

 * whether deletability of the column's relation should be required, so

 * we want that decision in C code where we could change it without initdb.

 */

Datum

pg_column_is_updatable(PG_FUNCTION_ARGS)

{

  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);

}

/*

 * pg_input_is_valid - test whether string is valid input for datatype.

 *

 * Returns true if OK, false if not.

 *

 * This will only work usefully if the datatype's input function has been

 * updated to return "soft" errors via errsave/ereturn.

 */

Datum

pg_input_is_valid(PG_FUNCTION_ARGS)

{

  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));

}

/*

 * pg_input_error_info - test whether string is valid input for datatype.

 *

 * Returns NULL if OK, else the primary message, detail message, hint message

 * and sql error code from the error.

 *

 * This will only work usefully if the datatype's input function has been

 * updated to return "soft" errors via errsave/ereturn.

 */

Datum

pg_input_error_info(PG_FUNCTION_ARGS)

{

  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));

}

/* Common subroutine for the above */

static bool

pg_input_is_valid_common(FunctionCallInfo fcinfo,

             text *txt, text *typname,

             ErrorSaveContext *escontext)

{

  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);

}

/*

 * Is character a valid identifier start?

 * Must match scan.l's {ident_start} character class.

 */

static bool

is_ident_start(unsigned char 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;

}

/*

 * Is character a valid identifier continuation?

 * Must match scan.l's {ident_cont} character class.

 */

static bool

is_ident_cont(unsigned char 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);

}

/*

 * parse_ident - parse a SQL qualified identifier into separate identifiers.

 * When strict mode is active (second parameter), then any chars after

 * the last identifier are disallowed.

 */

Datum

parse_ident(PG_FUNCTION_ARGS)

{

  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 == '.')