/*-------------------------------------------------------------------------
 *
 * tsearchcmds.c
 *
 *   Routines for tsearch manipulation commands
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/commands/tsearchcmds.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <ctype.h>

#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_config_map.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "common/string.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/parse_func.h"
#include "tsearch/ts_cache.h"
#include "tsearch/ts_public.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

/* Single entry of List returned by getTokenTypes() */
typedef struct
{
 int   num;   /* token type number */
 char    *name;   /* token type name */
} TSTokenTypeItem;

static void MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
          HeapTuple tup, Relation relMap);
static void DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
          HeapTuple tup, Relation relMap);
static DefElem *buildDefItem(const char *name, const char *val,
        bool was_quoted);


/* --------------------- TS Parser commands ------------------------ */

/*
 * lookup a parser support function and return its OID (as a Datum)
 *
 * attnum is the pg_ts_parser column the function will go into
 */
static Datum
get_ts_parser_func(DefElem *defel, int attnum)
{
 List    *funcName = defGetQualifiedName(defel);
 Oid   typeId[3];
 Oid   retTypeId;
 int   nargs;
 Oid   procOid;

 retTypeId = INTERNALOID; /* correct for most */
 typeId[0] = INTERNALOID;
 switch (attnum)
 {
  case Anum_pg_ts_parser_prsstart:
   nargs = 2;
   typeId[1] = INT4OID;
   break;
  case Anum_pg_ts_parser_prstoken:
   nargs = 3;
   typeId[1] = INTERNALOID;
   typeId[2] = INTERNALOID;
   break;
  case Anum_pg_ts_parser_prsend:
   nargs = 1;
   retTypeId = VOIDOID;
   break;
  case Anum_pg_ts_parser_prsheadline:
   nargs = 3;
   typeId[1] = INTERNALOID;
   typeId[2] = TSQUERYOID;
   break;
  case Anum_pg_ts_parser_prslextype:
   nargs = 1;

   /*
    * Note: because the lextype method returns type internal, it must
    * have an internal-type argument for security reasons.  The
    * argument is not actually used, but is just passed as a zero.
 */
   break;
  default:
   /* should not be here */
   elog(ERROR, "unrecognized attribute for text search parser: %d",
     attnum);
   nargs = 0;   /* keep compiler quiet */
 }

 procOid = LookupFuncName(funcName, nargs, typeId, false);
 if (get_func_rettype(procOid) != retTypeId)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("function %s should return type %s",
      func_signature_string(funcName, nargs, NIL, typeId),
      format_type_be(retTypeId))));

 return ObjectIdGetDatum(procOid);
}

/*
 * make pg_depend entries for a new pg_ts_parser entry
 *
 * Return value is the address of said new entry.
 */
static ObjectAddress
makeParserDependencies(HeapTuple tuple)
{
 Form_pg_ts_parser prs = (Form_pg_ts_parser) GETSTRUCT(tuple);
 ObjectAddress myself,
    referenced;
 ObjectAddresses *addrs;

 ObjectAddressSet(myself, TSParserRelationId, prs->oid);

 /* dependency on extension */
 recordDependencyOnCurrentExtension(&myself, false);

 addrs = new_object_addresses();

 /* dependency on namespace */
 ObjectAddressSet(referenced, NamespaceRelationId, prs->prsnamespace);
 add_exact_object_address(&referenced, addrs);

 /* dependencies on functions */
 ObjectAddressSet(referenced, ProcedureRelationId, prs->prsstart);
 add_exact_object_address(&referenced, addrs);

 referenced.objectId = prs->prstoken;
 add_exact_object_address(&referenced, addrs);

 referenced.objectId = prs->prsend;
 add_exact_object_address(&referenced, addrs);

 referenced.objectId = prs->prslextype;
 add_exact_object_address(&referenced, addrs);

 if (OidIsValid(prs->prsheadline))
 {
  referenced.objectId = prs->prsheadline;
  add_exact_object_address(&referenced, addrs);
 }

 record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
 free_object_addresses(addrs);

 return myself;
}

/*
 * CREATE TEXT SEARCH PARSER
 */
ObjectAddress
DefineTSParser(List *names, List *parameters)
{
 char    *prsname;
 ListCell   *pl;
 Relation prsRel;
 HeapTuple tup;
 Datum  values[Natts_pg_ts_parser];
 bool  nulls[Natts_pg_ts_parser];
 NameData pname;
 Oid   prsOid;
 Oid   namespaceoid;
 ObjectAddress address;

 if (!superuser())
  ereport(ERROR,
    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     errmsg("must be superuser to create text search parsers")));

 prsRel = table_open(TSParserRelationId, RowExclusiveLock);

 /* Convert list of names to a name and namespace */
 namespaceoid = QualifiedNameGetCreationNamespace(names, &prsname);

 /* initialize tuple fields with name/namespace */
 memset(values, 0, sizeof(values));
 memset(nulls, false, sizeof(nulls));

 prsOid = GetNewOidWithIndex(prsRel, TSParserOidIndexId,
        Anum_pg_ts_parser_oid);
 values[Anum_pg_ts_parser_oid - 1] = ObjectIdGetDatum(prsOid);
 namestrcpy(&pname, prsname);
 values[Anum_pg_ts_parser_prsname - 1] = NameGetDatum(&pname);
 values[Anum_pg_ts_parser_prsnamespace - 1] = ObjectIdGetDatum(namespaceoid);

 /*
  * loop over the definition list and extract the information we need.
 */
 foreach(pl, parameters)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);

  if (strcmp(defel->defname, "start") == 0)
  {
   values[Anum_pg_ts_parser_prsstart - 1] =
    get_ts_parser_func(defel, Anum_pg_ts_parser_prsstart);
  }
  else if (strcmp(defel->defname, "gettoken") == 0)
  {
   values[Anum_pg_ts_parser_prstoken - 1] =
    get_ts_parser_func(defel, Anum_pg_ts_parser_prstoken);
  }
  else if (strcmp(defel->defname, "end") == 0)
  {
   values[Anum_pg_ts_parser_prsend - 1] =
    get_ts_parser_func(defel, Anum_pg_ts_parser_prsend);
  }
  else if (strcmp(defel->defname, "headline") == 0)
  {
   values[Anum_pg_ts_parser_prsheadline - 1] =
    get_ts_parser_func(defel, Anum_pg_ts_parser_prsheadline);
  }
  else if (strcmp(defel->defname, "lextypes") == 0)
  {
   values[Anum_pg_ts_parser_prslextype - 1] =
    get_ts_parser_func(defel, Anum_pg_ts_parser_prslextype);
  }
  else
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("text search parser parameter \"%s\" not recognized",
       defel->defname)));
 }

 /*
  * Validation
 */
 if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prsstart - 1])))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search parser start method is required")));

 if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prstoken - 1])))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search parser gettoken method is required")));

 if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prsend - 1])))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search parser end method is required")));

 if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prslextype - 1])))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search parser lextypes method is required")));

 /*
  * Looks good, insert
 */
 tup = heap_form_tuple(prsRel->rd_att, values, nulls);

 CatalogTupleInsert(prsRel, tup);

 address = makeParserDependencies(tup);

 /* Post creation hook for new text search parser */
 InvokeObjectPostCreateHook(TSParserRelationId, prsOid, 0);

 heap_freetuple(tup);

 table_close(prsRel, RowExclusiveLock);

 return address;
}

/* ---------------------- TS Dictionary commands -----------------------*/

/*
 * make pg_depend entries for a new pg_ts_dict entry
 *
 * Return value is address of the new entry
 */
static ObjectAddress
makeDictionaryDependencies(HeapTuple tuple)
{
 Form_pg_ts_dict dict = (Form_pg_ts_dict) GETSTRUCT(tuple);
 ObjectAddress myself,
    referenced;
 ObjectAddresses *addrs;

 ObjectAddressSet(myself, TSDictionaryRelationId, dict->oid);

 /* dependency on owner */
 recordDependencyOnOwner(myself.classId, myself.objectId, dict->dictowner);

 /* dependency on extension */
 recordDependencyOnCurrentExtension(&myself, false);

 addrs = new_object_addresses();

 /* dependency on namespace */
 ObjectAddressSet(referenced, NamespaceRelationId, dict->dictnamespace);
 add_exact_object_address(&referenced, addrs);

 /* dependency on template */
 ObjectAddressSet(referenced, TSTemplateRelationId, dict->dicttemplate);
 add_exact_object_address(&referenced, addrs);

 record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
 free_object_addresses(addrs);

 return myself;
}

/*
 * verify that a template's init method accepts a proposed option list
 */
static void
verify_dictoptions(Oid tmplId, List *dictoptions)
{
 HeapTuple tup;
 Form_pg_ts_template tform;
 Oid   initmethod;

 /*
  * Suppress this test when running in a standalone backend.  This is a
  * hack to allow initdb to create prefab dictionaries that might not
  * actually be usable in template1's encoding (due to using external files
  * that can't be translated into template1's encoding).  We want to create
  * them anyway, since they might be usable later in other databases.
 */
 if (!IsUnderPostmaster)
  return;

 tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(tmplId));
 if (!HeapTupleIsValid(tup)) /* should not happen */
  elog(ERROR, "cache lookup failed for text search template %u",
    tmplId);
 tform = (Form_pg_ts_template) GETSTRUCT(tup);

 initmethod = tform->tmplinit;

 if (!OidIsValid(initmethod))
 {
  /* If there is no init method, disallow any options */
  if (dictoptions)
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("text search template \"%s\" does not accept options",
       NameStr(tform->tmplname))));
 }
 else
 {
  /*
   * Copy the options just in case init method thinks it can scribble on
   * them ...
 */
  dictoptions = copyObject(dictoptions);

  /*
   * Call the init method and see if it complains.  We don't worry about
   * it leaking memory, since our command will soon be over anyway.
 */
  (void) OidFunctionCall1(initmethod, PointerGetDatum(dictoptions));
 }

 ReleaseSysCache(tup);
}

/*
 * CREATE TEXT SEARCH DICTIONARY
 */
ObjectAddress
DefineTSDictionary(List *names, List *parameters)
{
 ListCell   *pl;
 Relation dictRel;
 HeapTuple tup;
 Datum  values[Natts_pg_ts_dict];
 bool  nulls[Natts_pg_ts_dict];
 NameData dname;
 Oid   templId = InvalidOid;
 List    *dictoptions = NIL;
 Oid   dictOid;
 Oid   namespaceoid;
 AclResult aclresult;
 char    *dictname;
 ObjectAddress address;

 /* Convert list of names to a name and namespace */
 namespaceoid = QualifiedNameGetCreationNamespace(names, &dictname);

 /* Check we have creation rights in target namespace */
 aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error(aclresult, OBJECT_SCHEMA,
        get_namespace_name(namespaceoid));

 /*
  * loop over the definition list and extract the information we need.
 */
 foreach(pl, parameters)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);

  if (strcmp(defel->defname, "template") == 0)
  {
   templId = get_ts_template_oid(defGetQualifiedName(defel), false);
  }
  else
  {
   /* Assume it's an option for the dictionary itself */
   dictoptions = lappend(dictoptions, defel);
  }
 }

 /*
  * Validation
 */
 if (!OidIsValid(templId))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search template is required")));

 verify_dictoptions(templId, dictoptions);


 dictRel = table_open(TSDictionaryRelationId, RowExclusiveLock);

 /*
  * Looks good, insert
 */
 memset(values, 0, sizeof(values));
 memset(nulls, false, sizeof(nulls));

 dictOid = GetNewOidWithIndex(dictRel, TSDictionaryOidIndexId,
         Anum_pg_ts_dict_oid);
 values[Anum_pg_ts_dict_oid - 1] = ObjectIdGetDatum(dictOid);
 namestrcpy(&dname, dictname);
 values[Anum_pg_ts_dict_dictname - 1] = NameGetDatum(&dname);
 values[Anum_pg_ts_dict_dictnamespace - 1] = ObjectIdGetDatum(namespaceoid);
 values[Anum_pg_ts_dict_dictowner - 1] = ObjectIdGetDatum(GetUserId());
 values[Anum_pg_ts_dict_dicttemplate - 1] = ObjectIdGetDatum(templId);
 if (dictoptions)
  values[Anum_pg_ts_dict_dictinitoption - 1] =
   PointerGetDatum(serialize_deflist(dictoptions));
 else
  nulls[Anum_pg_ts_dict_dictinitoption - 1] = true;

 tup = heap_form_tuple(dictRel->rd_att, values, nulls);

 CatalogTupleInsert(dictRel, tup);

 address = makeDictionaryDependencies(tup);

 /* Post creation hook for new text search dictionary */
 InvokeObjectPostCreateHook(TSDictionaryRelationId, dictOid, 0);

 heap_freetuple(tup);

 table_close(dictRel, RowExclusiveLock);

 return address;
}

/*
 * ALTER TEXT SEARCH DICTIONARY
 */
ObjectAddress
AlterTSDictionary(AlterTSDictionaryStmt *stmt)
{
 HeapTuple tup,
    newtup;
 Relation rel;
 Oid   dictId;
 ListCell   *pl;
 List    *dictoptions;
 Datum  opt;
 bool  isnull;
 Datum  repl_val[Natts_pg_ts_dict];
 bool  repl_null[Natts_pg_ts_dict];
 bool  repl_repl[Natts_pg_ts_dict];
 ObjectAddress address;

 dictId = get_ts_dict_oid(stmt->dictname, false);

 rel = table_open(TSDictionaryRelationId, RowExclusiveLock);

 tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));

 if (!HeapTupleIsValid(tup))
  elog(ERROR, "cache lookup failed for text search dictionary %u",
    dictId);

 /* must be owner */
 if (!object_ownercheck(TSDictionaryRelationId, dictId, GetUserId()))
  aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TSDICTIONARY,
        NameListToString(stmt->dictname));

 /* deserialize the existing set of options */
 opt = SysCacheGetAttr(TSDICTOID, tup,
        Anum_pg_ts_dict_dictinitoption,
        &isnull);
 if (isnull)
  dictoptions = NIL;
 else
  dictoptions = deserialize_deflist(opt);

 /*
  * Modify the options list as per specified changes
 */
 foreach(pl, stmt->options)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);
  ListCell   *cell;

  /*
   * Remove any matches ...
 */
  foreach(cell, dictoptions)
  {
   DefElem    *oldel = (DefElem *) lfirst(cell);

   if (strcmp(oldel->defname, defel->defname) == 0)
    dictoptions = foreach_delete_current(dictoptions, cell);
  }

  /*
   * and add new value if it's got one
 */
  if (defel->arg)
   dictoptions = lappend(dictoptions, defel);
 }

 /*
  * Validate
 */
 verify_dictoptions(((Form_pg_ts_dict) GETSTRUCT(tup))->dicttemplate,
        dictoptions);

 /*
  * Looks good, update
 */
 memset(repl_val, 0, sizeof(repl_val));
 memset(repl_null, false, sizeof(repl_null));
 memset(repl_repl, false, sizeof(repl_repl));

 if (dictoptions)
  repl_val[Anum_pg_ts_dict_dictinitoption - 1] =
   PointerGetDatum(serialize_deflist(dictoptions));
 else
  repl_null[Anum_pg_ts_dict_dictinitoption - 1] = true;
 repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = true;

 newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
          repl_val, repl_null, repl_repl);

 CatalogTupleUpdate(rel, &newtup->t_self, newtup);

 InvokeObjectPostAlterHook(TSDictionaryRelationId, dictId, 0);

 ObjectAddressSet(address, TSDictionaryRelationId, dictId);

 /*
  * NOTE: because we only support altering the options, not the template,
  * there is no need to update dependencies.  This might have to change if
  * the options ever reference inside-the-database objects.
 */

 heap_freetuple(newtup);
 ReleaseSysCache(tup);

 table_close(rel, RowExclusiveLock);

 return address;
}

/* ---------------------- TS Template commands -----------------------*/

/*
 * lookup a template support function and return its OID (as a Datum)
 *
 * attnum is the pg_ts_template column the function will go into
 */
static Datum
get_ts_template_func(DefElem *defel, int attnum)
{
 List    *funcName = defGetQualifiedName(defel);
 Oid   typeId[4];
 Oid   retTypeId;
 int   nargs;
 Oid   procOid;

 retTypeId = INTERNALOID;
 typeId[0] = INTERNALOID;
 typeId[1] = INTERNALOID;
 typeId[2] = INTERNALOID;
 typeId[3] = INTERNALOID;
 switch (attnum)
 {
  case Anum_pg_ts_template_tmplinit:
   nargs = 1;
   break;
  case Anum_pg_ts_template_tmpllexize:
   nargs = 4;
   break;
  default:
   /* should not be here */
   elog(ERROR, "unrecognized attribute for text search template: %d",
     attnum);
   nargs = 0;   /* keep compiler quiet */
 }

 procOid = LookupFuncName(funcName, nargs, typeId, false);
 if (get_func_rettype(procOid) != retTypeId)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("function %s should return type %s",
      func_signature_string(funcName, nargs, NIL, typeId),
      format_type_be(retTypeId))));

 return ObjectIdGetDatum(procOid);
}

/*
 * make pg_depend entries for a new pg_ts_template entry
 */
static ObjectAddress
makeTSTemplateDependencies(HeapTuple tuple)
{
 Form_pg_ts_template tmpl = (Form_pg_ts_template) GETSTRUCT(tuple);
 ObjectAddress myself,
    referenced;
 ObjectAddresses *addrs;

 ObjectAddressSet(myself, TSTemplateRelationId, tmpl->oid);

 /* dependency on extension */
 recordDependencyOnCurrentExtension(&myself, false);

 addrs = new_object_addresses();

 /* dependency on namespace */
 ObjectAddressSet(referenced, NamespaceRelationId, tmpl->tmplnamespace);
 add_exact_object_address(&referenced, addrs);

 /* dependencies on functions */
 ObjectAddressSet(referenced, ProcedureRelationId, tmpl->tmpllexize);
 add_exact_object_address(&referenced, addrs);

 if (OidIsValid(tmpl->tmplinit))
 {
  referenced.objectId = tmpl->tmplinit;
  add_exact_object_address(&referenced, addrs);
 }

 record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
 free_object_addresses(addrs);

 return myself;
}

/*
 * CREATE TEXT SEARCH TEMPLATE
 */
ObjectAddress
DefineTSTemplate(List *names, List *parameters)
{
 ListCell   *pl;
 Relation tmplRel;
 HeapTuple tup;
 Datum  values[Natts_pg_ts_template];
 bool  nulls[Natts_pg_ts_template];
 NameData dname;
 int   i;
 Oid   tmplOid;
 Oid   namespaceoid;
 char    *tmplname;
 ObjectAddress address;

 if (!superuser())
  ereport(ERROR,
    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     errmsg("must be superuser to create text search templates")));

 /* Convert list of names to a name and namespace */
 namespaceoid = QualifiedNameGetCreationNamespace(names, &tmplname);

 tmplRel = table_open(TSTemplateRelationId, RowExclusiveLock);

 for (i = 0; i < Natts_pg_ts_template; i++)
 {
  nulls[i] = false;
  values[i] = ObjectIdGetDatum(InvalidOid);
 }

 tmplOid = GetNewOidWithIndex(tmplRel, TSTemplateOidIndexId,
         Anum_pg_ts_dict_oid);
 values[Anum_pg_ts_template_oid - 1] = ObjectIdGetDatum(tmplOid);
 namestrcpy(&dname, tmplname);
 values[Anum_pg_ts_template_tmplname - 1] = NameGetDatum(&dname);
 values[Anum_pg_ts_template_tmplnamespace - 1] = ObjectIdGetDatum(namespaceoid);

 /*
  * loop over the definition list and extract the information we need.
 */
 foreach(pl, parameters)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);

  if (strcmp(defel->defname, "init") == 0)
  {
   values[Anum_pg_ts_template_tmplinit - 1] =
    get_ts_template_func(defel, Anum_pg_ts_template_tmplinit);
   nulls[Anum_pg_ts_template_tmplinit - 1] = false;
  }
  else if (strcmp(defel->defname, "lexize") == 0)
  {
   values[Anum_pg_ts_template_tmpllexize - 1] =
    get_ts_template_func(defel, Anum_pg_ts_template_tmpllexize);
   nulls[Anum_pg_ts_template_tmpllexize - 1] = false;
  }
  else
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("text search template parameter \"%s\" not recognized",
       defel->defname)));
 }

 /*
  * Validation
 */
 if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_template_tmpllexize - 1])))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search template lexize method is required")));

 /*
  * Looks good, insert
 */
 tup = heap_form_tuple(tmplRel->rd_att, values, nulls);

 CatalogTupleInsert(tmplRel, tup);

 address = makeTSTemplateDependencies(tup);

 /* Post creation hook for new text search template */
 InvokeObjectPostCreateHook(TSTemplateRelationId, tmplOid, 0);

 heap_freetuple(tup);

 table_close(tmplRel, RowExclusiveLock);

 return address;
}

/* ---------------------- TS Configuration commands -----------------------*/

/*
 * Finds syscache tuple of configuration.
 * Returns NULL if no such cfg.
 */
static HeapTuple
GetTSConfigTuple(List *names)
{
 HeapTuple tup;
 Oid   cfgId;

 cfgId = get_ts_config_oid(names, true);
 if (!OidIsValid(cfgId))
  return NULL;

 tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));

 if (!HeapTupleIsValid(tup)) /* should not happen */
  elog(ERROR, "cache lookup failed for text search configuration %u",
    cfgId);

 return tup;
}

/*
 * make pg_depend entries for a new or updated pg_ts_config entry
 *
 * Pass opened pg_ts_config_map relation if there might be any config map
 * entries for the config.
 */
static ObjectAddress
makeConfigurationDependencies(HeapTuple tuple, bool removeOld,
         Relation mapRel)
{
 Form_pg_ts_config cfg = (Form_pg_ts_config) GETSTRUCT(tuple);
 ObjectAddresses *addrs;
 ObjectAddress myself,
    referenced;

 myself.classId = TSConfigRelationId;
 myself.objectId = cfg->oid;
 myself.objectSubId = 0;

 /* for ALTER case, first flush old dependencies, except extension deps */
 if (removeOld)
 {
  deleteDependencyRecordsFor(myself.classId, myself.objectId, true);
  deleteSharedDependencyRecordsFor(myself.classId, myself.objectId, 0);
 }

 /*
  * We use an ObjectAddresses list to remove possible duplicate
  * dependencies from the config map info.  The pg_ts_config items
  * shouldn't be duplicates, but might as well fold them all into one call.
 */
 addrs = new_object_addresses();

 /* dependency on namespace */
 referenced.classId = NamespaceRelationId;
 referenced.objectId = cfg->cfgnamespace;
 referenced.objectSubId = 0;
 add_exact_object_address(&referenced, addrs);

 /* dependency on owner */
 recordDependencyOnOwner(myself.classId, myself.objectId, cfg->cfgowner);

 /* dependency on extension */
 recordDependencyOnCurrentExtension(&myself, removeOld);

 /* dependency on parser */
 referenced.classId = TSParserRelationId;
 referenced.objectId = cfg->cfgparser;
 referenced.objectSubId = 0;
 add_exact_object_address(&referenced, addrs);

 /* dependencies on dictionaries listed in config map */
 if (mapRel)
 {
  ScanKeyData skey;
  SysScanDesc scan;
  HeapTuple maptup;

  /* CCI to ensure we can see effects of caller's changes */
  CommandCounterIncrement();

  ScanKeyInit(&skey,
     Anum_pg_ts_config_map_mapcfg,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(myself.objectId));

  scan = systable_beginscan(mapRel, TSConfigMapIndexId, true,
          NULL, 1, &skey);

  while (HeapTupleIsValid((maptup = systable_getnext(scan))))
  {
   Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);

   referenced.classId = TSDictionaryRelationId;
   referenced.objectId = cfgmap->mapdict;
   referenced.objectSubId = 0;
   add_exact_object_address(&referenced, addrs);
  }

  systable_endscan(scan);
 }

 /* Record 'em (this includes duplicate elimination) */
 record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);

 free_object_addresses(addrs);

 return myself;
}

/*
 * CREATE TEXT SEARCH CONFIGURATION
 */
ObjectAddress
DefineTSConfiguration(List *names, List *parameters, ObjectAddress *copied)
{
 Relation cfgRel;
 Relation mapRel = NULL;
 HeapTuple tup;
 Datum  values[Natts_pg_ts_config];
 bool  nulls[Natts_pg_ts_config];
 AclResult aclresult;
 Oid   namespaceoid;
 char    *cfgname;
 NameData cname;
 Oid   sourceOid = InvalidOid;
 Oid   prsOid = InvalidOid;
 Oid   cfgOid;
 ListCell   *pl;
 ObjectAddress address;

 /* Convert list of names to a name and namespace */
 namespaceoid = QualifiedNameGetCreationNamespace(names, &cfgname);

 /* Check we have creation rights in target namespace */
 aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error(aclresult, OBJECT_SCHEMA,
        get_namespace_name(namespaceoid));

 /*
  * loop over the definition list and extract the information we need.
 */
 foreach(pl, parameters)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);

  if (strcmp(defel->defname, "parser") == 0)
   prsOid = get_ts_parser_oid(defGetQualifiedName(defel), false);
  else if (strcmp(defel->defname, "copy") == 0)
   sourceOid = get_ts_config_oid(defGetQualifiedName(defel), false);
  else
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("text search configuration parameter \"%s\" not recognized",
       defel->defname)));
 }

 if (OidIsValid(sourceOid) && OidIsValid(prsOid))
  ereport(ERROR,
    (errcode(ERRCODE_SYNTAX_ERROR),
     errmsg("cannot specify both PARSER and COPY options")));

 /* make copied tsconfig available to callers */
 if (copied && OidIsValid(sourceOid))
 {
  ObjectAddressSet(*copied,
       TSConfigRelationId,
       sourceOid);
 }

 /*
  * Look up source config if given.
 */
 if (OidIsValid(sourceOid))
 {
  Form_pg_ts_config cfg;

  tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(sourceOid));
  if (!HeapTupleIsValid(tup))
   elog(ERROR, "cache lookup failed for text search configuration %u",
     sourceOid);

  cfg = (Form_pg_ts_config) GETSTRUCT(tup);

  /* use source's parser */
  prsOid = cfg->cfgparser;

  ReleaseSysCache(tup);
 }

 /*
  * Validation
 */
 if (!OidIsValid(prsOid))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("text search parser is required")));

 cfgRel = table_open(TSConfigRelationId, RowExclusiveLock);

 /*
  * Looks good, build tuple and insert
 */
 memset(values, 0, sizeof(values));
 memset(nulls, false, sizeof(nulls));

 cfgOid = GetNewOidWithIndex(cfgRel, TSConfigOidIndexId,
        Anum_pg_ts_config_oid);
 values[Anum_pg_ts_config_oid - 1] = ObjectIdGetDatum(cfgOid);
 namestrcpy(&cname, cfgname);
 values[Anum_pg_ts_config_cfgname - 1] = NameGetDatum(&cname);
 values[Anum_pg_ts_config_cfgnamespace - 1] = ObjectIdGetDatum(namespaceoid);
 values[Anum_pg_ts_config_cfgowner - 1] = ObjectIdGetDatum(GetUserId());
 values[Anum_pg_ts_config_cfgparser - 1] = ObjectIdGetDatum(prsOid);

 tup = heap_form_tuple(cfgRel->rd_att, values, nulls);

 CatalogTupleInsert(cfgRel, tup);

 if (OidIsValid(sourceOid))
 {
  /*
   * Copy token-dicts map from source config
 */
  ScanKeyData skey;
  SysScanDesc scan;
  HeapTuple maptup;
  TupleDesc mapDesc;
  TupleTableSlot **slot;
  CatalogIndexState indstate;
  int   max_slots,
     slot_init_count,
     slot_stored_count;

  mapRel = table_open(TSConfigMapRelationId, RowExclusiveLock);
  mapDesc = RelationGetDescr(mapRel);

  indstate = CatalogOpenIndexes(mapRel);

  /*
   * Allocate the slots to use, but delay costly initialization until we
   * know that they will be used.
 */
  max_slots = MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_ts_config_map);
  slot = palloc(sizeof(TupleTableSlot *) * max_slots);

  ScanKeyInit(&skey,
     Anum_pg_ts_config_map_mapcfg,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(sourceOid));

  scan = systable_beginscan(mapRel, TSConfigMapIndexId, true,
          NULL, 1, &skey);

  /* number of slots currently storing tuples */
  slot_stored_count = 0;
  /* number of slots currently initialized */
  slot_init_count = 0;

  while (HeapTupleIsValid((maptup = systable_getnext(scan))))
  {
   Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);

   if (slot_init_count < max_slots)
   {
    slot[slot_stored_count] = MakeSingleTupleTableSlot(mapDesc,
                   &TTSOpsHeapTuple);
    slot_init_count++;
   }

   ExecClearTuple(slot[slot_stored_count]);

   memset(slot[slot_stored_count]->tts_isnull, false,
       slot[slot_stored_count]->tts_tupleDescriptor->natts * sizeof(bool));

   slot[slot_stored_count]->tts_values[Anum_pg_ts_config_map_mapcfg - 1] = cfgOid;
   slot[slot_stored_count]->tts_values[Anum_pg_ts_config_map_maptokentype - 1] = cfgmap->maptokentype;
   slot[slot_stored_count]->tts_values[Anum_pg_ts_config_map_mapseqno - 1] = cfgmap->mapseqno;
   slot[slot_stored_count]->tts_values[Anum_pg_ts_config_map_mapdict - 1] = cfgmap->mapdict;

   ExecStoreVirtualTuple(slot[slot_stored_count]);
   slot_stored_count++;

   /* If slots are full, insert a batch of tuples */
   if (slot_stored_count == max_slots)
   {
    CatalogTuplesMultiInsertWithInfo(mapRel, slot, slot_stored_count,
             indstate);
    slot_stored_count = 0;
   }
  }

  /* Insert any tuples left in the buffer */
  if (slot_stored_count > 0)
   CatalogTuplesMultiInsertWithInfo(mapRel, slot, slot_stored_count,
            indstate);

  for (int i = 0; i < slot_init_count; i++)
   ExecDropSingleTupleTableSlot(slot[i]);

  systable_endscan(scan);
  CatalogCloseIndexes(indstate);
 }

 address = makeConfigurationDependencies(tup, false, mapRel);

 /* Post creation hook for new text search configuration */
 InvokeObjectPostCreateHook(TSConfigRelationId, cfgOid, 0);

 heap_freetuple(tup);

 if (mapRel)
  table_close(mapRel, RowExclusiveLock);
 table_close(cfgRel, RowExclusiveLock);

 return address;
}

/*
 * Guts of TS configuration deletion.
 */
void
RemoveTSConfigurationById(Oid cfgId)
{
 Relation relCfg,
    relMap;
 HeapTuple tup;
 ScanKeyData skey;
 SysScanDesc scan;

 /* Remove the pg_ts_config entry */
 relCfg = table_open(TSConfigRelationId, RowExclusiveLock);

 tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));

 if (!HeapTupleIsValid(tup))
  elog(ERROR, "cache lookup failed for text search dictionary %u",
    cfgId);

 CatalogTupleDelete(relCfg, &tup->t_self);

 ReleaseSysCache(tup);

 table_close(relCfg, RowExclusiveLock);

 /* Remove any pg_ts_config_map entries */
 relMap = table_open(TSConfigMapRelationId, RowExclusiveLock);

 ScanKeyInit(&skey,
    Anum_pg_ts_config_map_mapcfg,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(cfgId));

 scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
         NULL, 1, &skey);

 while (HeapTupleIsValid((tup = systable_getnext(scan))))
 {
  CatalogTupleDelete(relMap, &tup->t_self);
 }

 systable_endscan(scan);

 table_close(relMap, RowExclusiveLock);
}

/*
 * ALTER TEXT SEARCH CONFIGURATION - main entry point
 */
ObjectAddress
AlterTSConfiguration(AlterTSConfigurationStmt *stmt)
{
 HeapTuple tup;
 Oid   cfgId;
 Relation relMap;
 ObjectAddress address;

 /* Find the configuration */
 tup = GetTSConfigTuple(stmt->cfgname);
 if (!HeapTupleIsValid(tup))
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_OBJECT),
     errmsg("text search configuration \"%s\" does not exist",
      NameListToString(stmt->cfgname))));

 cfgId = ((Form_pg_ts_config) GETSTRUCT(tup))->oid;

 /* must be owner */
 if (!object_ownercheck(TSConfigRelationId, cfgId, GetUserId()))
  aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TSCONFIGURATION,
        NameListToString(stmt->cfgname));

 relMap = table_open(TSConfigMapRelationId, RowExclusiveLock);

 /* Add or drop mappings */
 if (stmt->dicts)
  MakeConfigurationMapping(stmt, tup, relMap);
 else if (stmt->tokentype)
  DropConfigurationMapping(stmt, tup, relMap);

 /* Update dependencies */
 makeConfigurationDependencies(tup, true, relMap);

 InvokeObjectPostAlterHook(TSConfigRelationId, cfgId, 0);

 ObjectAddressSet(address, TSConfigRelationId, cfgId);

 table_close(relMap, RowExclusiveLock);

 ReleaseSysCache(tup);

 return address;
}

/*
 * Check whether a token type name is a member of a TSTokenTypeItem list.
 */
static bool
tstoken_list_member(char *token_name, List *tokens)
{
 ListCell   *c;
 bool  found = false;

 foreach(c, tokens)
 {
  TSTokenTypeItem *ts = (TSTokenTypeItem *) lfirst(c);

  if (strcmp(token_name, ts->name) == 0)
  {
   found = true;
   break;
  }
 }

 return found;
}

/*
 * Translate a list of token type names to a list of unique TSTokenTypeItem.
 *
 * Duplicated entries list are removed from tokennames.
 */
static List *
getTokenTypes(Oid prsId, List *tokennames)
{
 TSParserCacheEntry *prs = lookup_ts_parser_cache(prsId);
 LexDescr   *list;
 List    *result = NIL;
 int   ntoken;
 ListCell   *tn;

 ntoken = list_length(tokennames);
 if (ntoken == 0)
  return NIL;

 if (!OidIsValid(prs->lextypeOid))
  elog(ERROR, "method lextype isn't defined for text search parser %u",
    prsId);

 /* lextype takes one dummy argument */
 list = (LexDescr *) DatumGetPointer(OidFunctionCall1(prs->lextypeOid,
               (Datum) 0));

 foreach(tn, tokennames)
 {
  String    *val = lfirst_node(String, tn);
  bool  found = false;
  int   j;

  /* Skip if this token is already in the result */
  if (tstoken_list_member(strVal(val), result))
   continue;

  j = 0;
  while (list && list[j].lexid)
  {
   if (strcmp(strVal(val), list[j].alias) == 0)
   {
    TSTokenTypeItem *ts = (TSTokenTypeItem *) palloc0(sizeof(TSTokenTypeItem));

    ts->num = list[j].lexid;
    ts->name = pstrdup(strVal(val));
    result = lappend(result, ts);
    found = true;
    break;
   }
   j++;
  }
  if (!found)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      errmsg("token type \"%s\" does not exist",
       strVal(val))));
 }

 return result;
}

/*
 * ALTER TEXT SEARCH CONFIGURATION ADD/ALTER MAPPING
 */
static void
MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
       HeapTuple tup, Relation relMap)
{
 Form_pg_ts_config tsform;
 Oid   cfgId;
 ScanKeyData skey[2];
 SysScanDesc scan;
 HeapTuple maptup;
 int   i;
 int   j;
 Oid   prsId;
 List    *tokens = NIL;
 int   ntoken;
 Oid     *dictIds;
 int   ndict;
 ListCell   *c;
 CatalogIndexState indstate;

 tsform = (Form_pg_ts_config) GETSTRUCT(tup);
 cfgId = tsform->oid;
 prsId = tsform->cfgparser;

 tokens = getTokenTypes(prsId, stmt->tokentype);
 ntoken = list_length(tokens);

 if (stmt->override)
 {
  /*
   * delete maps for tokens if they exist and command was ALTER
 */
  foreach(c, tokens)
  {
   TSTokenTypeItem *ts = (TSTokenTypeItem *) lfirst(c);

   ScanKeyInit(&skey[0],
      Anum_pg_ts_config_map_mapcfg,
      BTEqualStrategyNumber, F_OIDEQ,
      ObjectIdGetDatum(cfgId));
   ScanKeyInit(&skey[1],
      Anum_pg_ts_config_map_maptokentype,
      BTEqualStrategyNumber, F_INT4EQ,
      Int32GetDatum(ts->num));

   scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
           NULL, 2, skey);

   while (HeapTupleIsValid((maptup = systable_getnext(scan))))
   {
    CatalogTupleDelete(relMap, &maptup->t_self);
   }

   systable_endscan(scan);
  }
 }

 /*
  * Convert list of dictionary names to array of dict OIDs
 */
 ndict = list_length(stmt->dicts);
 dictIds = (Oid *) palloc(sizeof(Oid) * ndict);
 i = 0;
 foreach(c, stmt->dicts)
 {
  List    *names = (List *) lfirst(c);

  dictIds[i] = get_ts_dict_oid(names, false);
  i++;
 }

 indstate = CatalogOpenIndexes(relMap);

 if (stmt->replace)
 {
  /*
   * Replace a specific dictionary in existing entries
 */
  Oid   dictOld = dictIds[0],
     dictNew = dictIds[1];

  ScanKeyInit(&skey[0],
     Anum_pg_ts_config_map_mapcfg,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(cfgId));

  scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
          NULL, 1, skey);

  while (HeapTupleIsValid((maptup = systable_getnext(scan))))
  {
   Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);

   /*
    * check if it's one of target token types
 */
   if (tokens)
   {
    bool  tokmatch = false;

    foreach(c, tokens)
    {
     TSTokenTypeItem *ts = (TSTokenTypeItem *) lfirst(c);

     if (cfgmap->maptokentype == ts->num)
     {
      tokmatch = true;
      break;
     }
    }
    if (!tokmatch)
     continue;
   }

   /*
    * replace dictionary if match
 */
   if (cfgmap->mapdict == dictOld)
   {
    Datum  repl_val[Natts_pg_ts_config_map];
    bool  repl_null[Natts_pg_ts_config_map];
    bool  repl_repl[Natts_pg_ts_config_map];
    HeapTuple newtup;

    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));

    repl_val[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictNew);
    repl_repl[Anum_pg_ts_config_map_mapdict - 1] = true;

    newtup = heap_modify_tuple(maptup,
             RelationGetDescr(relMap),
             repl_val, repl_null, repl_repl);
    CatalogTupleUpdateWithInfo(relMap, &newtup->t_self, newtup, indstate);
   }
  }

  systable_endscan(scan);
 }
 else
 {
  TupleTableSlot **slot;
  int   slotCount = 0;
  int   nslots;

  /* Allocate the slots to use and initialize them */
  nslots = Min(ntoken * ndict,
      MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_ts_config_map));
  slot = palloc(sizeof(TupleTableSlot *) * nslots);
  for (i = 0; i < nslots; i++)
   slot[i] = MakeSingleTupleTableSlot(RelationGetDescr(relMap),
              &TTSOpsHeapTuple);

  /*
   * Insertion of new entries
 */
  foreach(c, tokens)
  {
   TSTokenTypeItem *ts = (TSTokenTypeItem *) lfirst(c);

   for (j = 0; j < ndict; j++)
   {
    ExecClearTuple(slot[slotCount]);

    memset(slot[slotCount]->tts_isnull, false,
        slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));

    slot[slotCount]->tts_values[Anum_pg_ts_config_map_mapcfg - 1] = ObjectIdGetDatum(cfgId);
    slot[slotCount]->tts_values[Anum_pg_ts_config_map_maptokentype - 1] = Int32GetDatum(ts->num);
    slot[slotCount]->tts_values[Anum_pg_ts_config_map_mapseqno - 1] = Int32GetDatum(j + 1);
    slot[slotCount]->tts_values[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictIds[j]);

    ExecStoreVirtualTuple(slot[slotCount]);
    slotCount++;

    /* If slots are full, insert a batch of tuples */
    if (slotCount == nslots)
    {
     CatalogTuplesMultiInsertWithInfo(relMap, slot, slotCount,
              indstate);
     slotCount = 0;
    }
   }
  }

  /* Insert any tuples left in the buffer */
  if (slotCount > 0)
   CatalogTuplesMultiInsertWithInfo(relMap, slot, slotCount,
            indstate);

  for (i = 0; i < nslots; i++)
   ExecDropSingleTupleTableSlot(slot[i]);
 }

 /* clean up */
 CatalogCloseIndexes(indstate);

 EventTriggerCollectAlterTSConfig(stmt, cfgId, dictIds, ndict);
}

/*
 * ALTER TEXT SEARCH CONFIGURATION DROP MAPPING
 */
static void
DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
       HeapTuple tup, Relation relMap)
{
 Form_pg_ts_config tsform;
 Oid   cfgId;
 ScanKeyData skey[2];
 SysScanDesc scan;
 HeapTuple maptup;
 Oid   prsId;
 List    *tokens = NIL;
 ListCell   *c;

 tsform = (Form_pg_ts_config) GETSTRUCT(tup);
 cfgId = tsform->oid;
 prsId = tsform->cfgparser;

 tokens = getTokenTypes(prsId, stmt->tokentype);

 foreach(c, tokens)
 {
  TSTokenTypeItem *ts = (TSTokenTypeItem *) lfirst(c);
  bool  found = false;

  ScanKeyInit(&skey[0],
     Anum_pg_ts_config_map_mapcfg,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(cfgId));
  ScanKeyInit(&skey[1],
     Anum_pg_ts_config_map_maptokentype,
     BTEqualStrategyNumber, F_INT4EQ,
     Int32GetDatum(ts->num));

  scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
          NULL, 2, skey);

  while (HeapTupleIsValid((maptup = systable_getnext(scan))))
  {
   CatalogTupleDelete(relMap, &maptup->t_self);
   found = true;
  }

  systable_endscan(scan);

  if (!found)
  {
   if (!stmt->missing_ok)
   {
    ereport(ERROR,
      (errcode(ERRCODE_UNDEFINED_OBJECT),
       errmsg("mapping for token type \"%s\" does not exist",
        ts->name)));
   }
   else
   {
    ereport(NOTICE,
      (errmsg("mapping for token type \"%s\" does not exist, skipping",
        ts->name)));
   }
  }
 }

 EventTriggerCollectAlterTSConfig(stmt, cfgId, NULL, 0);
}


/*
 * Serialize dictionary options, producing a TEXT datum from a List of DefElem
 *
 * This is used to form the value stored in pg_ts_dict.dictinitoption.
 * For the convenience of pg_dump, the output is formatted exactly as it
 * would need to appear in CREATE TEXT SEARCH DICTIONARY to reproduce the
 * same options.
 */
text *
serialize_deflist(List *deflist)
{
 text    *result;
 StringInfoData buf;
 ListCell   *l;

 initStringInfo(&buf);

 foreach(l, deflist)
 {
  DefElem    *defel = (DefElem *) lfirst(l);
  char    *val = defGetString(defel);

  appendStringInfo(&buf, "%s = ",
       quote_identifier(defel->defname));

  /*
   * If the value is a T_Integer or T_Float, emit it without quotes,
   * otherwise with quotes.  This is essential to allow correct
   * reconstruction of the node type as well as the value.
 */
  if (IsA(defel->arg, Integer) || IsA(defel->arg, Float))
   appendStringInfoString(&buf, val);
  else
  {
   /* If backslashes appear, force E syntax to quote them safely */
   if (strchr(val, '\\'))
    appendStringInfoChar(&buf, ESCAPE_STRING_SYNTAX);
   appendStringInfoChar(&buf, '\'');
   while (*val)
   {
    char  ch = *val++;

    if (SQL_STR_DOUBLE(ch, true))
     appendStringInfoChar(&buf, ch);
    appendStringInfoChar(&buf, ch);
   }
   appendStringInfoChar(&buf, '\'');
  }
  if (lnext(deflist, l) != NULL)
   appendStringInfoString(&buf, ", ");
 }

 result = cstring_to_text_with_len(buf.data, buf.len);
 pfree(buf.data);
 return result;
}

/*
 * Deserialize dictionary options, reconstructing a List of DefElem from TEXT
 *
 * This is also used for prsheadline options, so for backward compatibility
 * we need to accept a few things serialize_deflist() will never emit:
 * in particular, unquoted and double-quoted strings.
 */
List *
deserialize_deflist(Datum txt)
{
 text    *in = DatumGetTextPP(txt); /* in case it's toasted */
 List    *result = NIL;
 int   len = VARSIZE_ANY_EXHDR(in);
 char    *ptr,
      *endptr,
      *workspace,
      *wsptr = NULL,
      *startvalue = NULL;
 typedef enum
 {
  CS_WAITKEY,
  CS_INKEY,
  CS_INQKEY,
  CS_WAITEQ,
  CS_WAITVALUE,
  CS_INSQVALUE,
  CS_INDQVALUE,
  CS_INWVALUE
 } ds_state;
 ds_state state = CS_WAITKEY;

 workspace = (char *) palloc(len + 1); /* certainly enough room */
 ptr = VARDATA_ANY(in);
 endptr = ptr + len;
 for (; ptr < endptr; ptr++)
 {
  switch (state)
  {
   case CS_WAITKEY:
    if (isspace((unsigned char) *ptr) || *ptr == ',')
     continue;
    if (*ptr == '"')
    {
     wsptr = workspace;
     state = CS_INQKEY;
    }
    else
    {
     wsptr = workspace;
     *wsptr++ = *ptr;
     state = CS_INKEY;
    }
    break;
   case CS_INKEY:
    if (isspace((unsigned char) *ptr))
    {
     *wsptr++ = '\0';
     state = CS_WAITEQ;
    }
    else if (*ptr == '=')
    {
     *wsptr++ = '\0';
     state = CS_WAITVALUE;
    }
    else
    {
     *wsptr++ = *ptr;
    }
    break;
   case CS_INQKEY:
    if (*ptr == '"')
    {
     if (ptr + 1 < endptr && ptr[1] == '"')
     {
      /* copy only one of the two quotes */
      *wsptr++ = *ptr++;
     }
     else
     {
      *wsptr++ = '\0';
      state = CS_WAITEQ;
     }
    }
    else
    {
     *wsptr++ = *ptr;
    }
    break;
   case CS_WAITEQ:
    if (*ptr == '=')
     state = CS_WAITVALUE;
    else if (!isspace((unsigned char) *ptr))
     ereport(ERROR,
       (errcode(ERRCODE_SYNTAX_ERROR),
        errmsg("invalid parameter list format: \"%s\"",
         text_to_cstring(in))));
    break;
   case CS_WAITVALUE:
    if (*ptr == '\'')
    {
     startvalue = wsptr;
     state = CS_INSQVALUE;
    }
    else if (*ptr == 'E' && ptr + 1 < endptr && ptr[1] == '\'')
    {
     ptr++;
     startvalue = wsptr;
     state = CS_INSQVALUE;
    }
    else if (*ptr == '"')
    {
     startvalue = wsptr;
     state = CS_INDQVALUE;
    }
    else if (!isspace((unsigned char) *ptr))
    {
     startvalue = wsptr;
     *wsptr++ = *ptr;
     state = CS_INWVALUE;
    }
    break;
   case CS_INSQVALUE:
    if (*ptr == '\'')
    {
     if (ptr + 1 < endptr && ptr[1] == '\'')
     {
      /* copy only one of the two quotes */
      *wsptr++ = *ptr++;
     }
     else
     {
      *wsptr++ = '\0';
      result = lappend(result,
           buildDefItem(workspace,
               startvalue,
               true));
      state = CS_WAITKEY;
     }
    }
    else if (*ptr == '\\')
    {
     if (ptr + 1 < endptr && ptr[1] == '\\')
     {
      /* copy only one of the two backslashes */
      *wsptr++ = *ptr++;
     }
     else
      *wsptr++ = *ptr;
    }
    else
    {
     *wsptr++ = *ptr;
    }
    break;
   case CS_INDQVALUE:
    if (*ptr == '"')
    {
     if (ptr + 1 < endptr && ptr[1] == '"')
     {
      /* copy only one of the two quotes */
      *wsptr++ = *ptr++;
     }
     else
     {
      *wsptr++ = '\0';
      result = lappend(result,
           buildDefItem(workspace,
               startvalue,
               true));
      state = CS_WAITKEY;
     }
    }
    else
    {
     *wsptr++ = *ptr;
    }
    break;
   case CS_INWVALUE:
    if (*ptr == ',' || isspace((unsigned char) *ptr))
    {
     *wsptr++ = '\0';
     result = lappend(result,
          buildDefItem(workspace,
              startvalue,
              false));
     state = CS_WAITKEY;
    }
    else
    {
     *wsptr++ = *ptr;
    }
    break;
   default:
    elog(ERROR, "unrecognized deserialize_deflist state: %d",
      state);
  }
 }

 if (state == CS_INWVALUE)
 {
  *wsptr++ = '\0';
  result = lappend(result,
       buildDefItem(workspace,
           startvalue,
           false));
 }
 else if (state != CS_WAITKEY)
  ereport(ERROR,
    (errcode(ERRCODE_SYNTAX_ERROR),
     errmsg("invalid parameter list format: \"%s\"",
      text_to_cstring(in))));

 pfree(workspace);

 return result;
}

/*
 * Build one DefElem for deserialize_deflist
 */
static DefElem *
buildDefItem(const char *name, const char *val, bool was_quoted)
{
 /* If input was quoted, always emit as string */
 if (!was_quoted && val[0] != '\0')
 {
  int   v;
  char    *endptr;

  /* Try to parse as an integer */
  errno = 0;
  v = strtoint(val, &endptr, 10);
  if (errno == 0 && *endptr == '\0')
   return makeDefElem(pstrdup(name),
          (Node *) makeInteger(v),
          -1);
  /* Nope, how about as a float? */
  errno = 0;
  (void) strtod(val, &endptr);
  if (errno == 0 && *endptr == '\0')
   return makeDefElem(pstrdup(name),
          (Node *) makeFloat(pstrdup(val)),
          -1);

  if (strcmp(val, "true") == 0)
   return makeDefElem(pstrdup(name),
          (Node *) makeBoolean(true),
          -1);
  if (strcmp(val, "false") == 0)
   return makeDefElem(pstrdup(name),
          (Node *) makeBoolean(false),
          -1);
 }
 /* Just make it a string */
 return makeDefElem(pstrdup(name),
        (Node *) makeString(pstrdup(val)),
        -1);
}