src/backend/commands/tsearchcmds.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * tsearchcmds.c
   4  *
   5  *        Routines for tsearch manipulation commands
   6  *
   7  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  *
  11  * IDENTIFICATION
  12  *        $PostgreSQL$
  13  *
  14  *-------------------------------------------------------------------------
  15  */
  16 #include "postgres.h"
  17
  18 #include <ctype.h>
  19
  20 #include "access/heapam.h"
  21 #include "access/genam.h"
  22 #include "access/xact.h"
  23 #include "catalog/dependency.h"
  24 #include "catalog/indexing.h"
  25 #include "catalog/namespace.h"
  26 #include "catalog/pg_namespace.h"
  27 #include "catalog/pg_proc.h"
  28 #include "catalog/pg_ts_config.h"
  29 #include "catalog/pg_ts_config_map.h"
  30 #include "catalog/pg_ts_dict.h"
  31 #include "catalog/pg_ts_parser.h"
  32 #include "catalog/pg_ts_template.h"
  33 #include "catalog/pg_type.h"
  34 #include "commands/defrem.h"
  35 #include "miscadmin.h"
  36 #include "nodes/makefuncs.h"
  37 #include "parser/parse_func.h"
  38 #include "tsearch/ts_cache.h"
  39 #include "tsearch/ts_public.h"
  40 #include "tsearch/ts_utils.h"
  41 #include "utils/acl.h"
  42 #include "utils/builtins.h"
  43 #include "utils/catcache.h"
  44 #include "utils/fmgroids.h"
  45 #include "utils/lsyscache.h"
  46 #include "utils/syscache.h"
  47 #include "utils/tqual.h"
  48
  49
  50 static void MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
  51                                                  HeapTuple tup, Relation relMap);
  52 static void DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
  53                                                  HeapTuple tup, Relation relMap);
  54
  55
  56 /* --------------------- TS Parser commands ------------------------ */
  57
  58 /*
  59  * lookup a parser support function and return its OID (as a Datum)
  60  *
  61  * attnum is the pg_ts_parser column the function will go into
  62  */
  63 static Datum
  64 get_ts_parser_func(DefElem *defel, int attnum)
  65 {
  66         List       *funcName = defGetQualifiedName(defel);
  67         Oid                     typeId[3];
  68         Oid                     retTypeId;
  69         int                     nargs;
  70         Oid                     procOid;
  71
  72         retTypeId = INTERNALOID;        /* correct for most */
  73         typeId[0] = INTERNALOID;
  74         switch (attnum)
  75         {
  76                 case Anum_pg_ts_parser_prsstart:
  77                         nargs = 2;
  78                         typeId[1] = INT4OID;
  79                         break;
  80                 case Anum_pg_ts_parser_prstoken:
  81                         nargs = 3;
  82                         typeId[1] = INTERNALOID;
  83                         typeId[2] = INTERNALOID;
  84                         break;
  85                 case Anum_pg_ts_parser_prsend:
  86                         nargs = 1;
  87                         retTypeId = VOIDOID;
  88                         break;
  89                 case Anum_pg_ts_parser_prsheadline:
  90                         nargs = 3;
  91                         typeId[1] = INTERNALOID;
  92                         typeId[2] = TSQUERYOID;
  93                         break;
  94                 case Anum_pg_ts_parser_prslextype:
  95                         nargs = 1;
  96                         break;
  97                 default:
  98                         /* should not be here */
  99                         elog(ERROR, "unrecognized attribute for text search parser: %d",
 100                                  attnum);
 101                         nargs = 0;                      /* keep compiler quiet */
 102         }
 103
 104         procOid = LookupFuncName(funcName, nargs, typeId, false);
 105         if (get_func_rettype(procOid) != retTypeId)
 106                 ereport(ERROR,
 107                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 108                                  errmsg("function %s should return type %s",
 109                                                 func_signature_string(funcName, nargs, typeId),
 110                                                 format_type_be(retTypeId))));
 111
 112         return ObjectIdGetDatum(procOid);
 113 }
 114
 115 /*
 116  * make pg_depend entries for a new pg_ts_parser entry
 117  */
 118 static void
 119 makeParserDependencies(HeapTuple tuple)
 120 {
 121         Form_pg_ts_parser prs = (Form_pg_ts_parser) GETSTRUCT(tuple);
 122         ObjectAddress myself,
 123                                 referenced;
 124
 125         myself.classId = TSParserRelationId;
 126         myself.objectId = HeapTupleGetOid(tuple);
 127         myself.objectSubId = 0;
 128
 129         /* dependency on namespace */
 130         referenced.classId = NamespaceRelationId;
 131         referenced.objectId = prs->prsnamespace;
 132         referenced.objectSubId = 0;
 133         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 134
 135         /* dependencies on functions */
 136         referenced.classId = ProcedureRelationId;
 137         referenced.objectSubId = 0;
 138
 139         referenced.objectId = prs->prsstart;
 140         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 141
 142         referenced.objectId = prs->prstoken;
 143         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 144
 145         referenced.objectId = prs->prsend;
 146         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 147
 148         referenced.objectId = prs->prslextype;
 149         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 150
 151         if (OidIsValid(prs->prsheadline))
 152         {
 153                 referenced.objectId = prs->prsheadline;
 154                 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 155         }
 156 }
 157
 158 /*
 159  * CREATE TEXT SEARCH PARSER
 160  */
 161 void
 162 DefineTSParser(List *names, List *parameters)
 163 {
 164         char       *prsname;
 165         ListCell   *pl;
 166         Relation        prsRel;
 167         HeapTuple       tup;
 168         Datum           values[Natts_pg_ts_parser];
 169         char            nulls[Natts_pg_ts_parser];
 170         NameData        pname;
 171         Oid                     prsOid;
 172         Oid                     namespaceoid;
 173
 174         if (!superuser())
 175                 ereport(ERROR,
 176                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 177                                  errmsg("must be superuser to create text search parsers")));
 178
 179         /* Convert list of names to a name and namespace */
 180         namespaceoid = QualifiedNameGetCreationNamespace(names, &prsname);
 181
 182         /* initialize tuple fields with name/namespace */
 183         memset(values, 0, sizeof(values));
 184         memset(nulls, ' ', sizeof(nulls));
 185
 186         namestrcpy(&pname, prsname);
 187         values[Anum_pg_ts_parser_prsname - 1] = NameGetDatum(&pname);
 188         values[Anum_pg_ts_parser_prsnamespace - 1] = ObjectIdGetDatum(namespaceoid);
 189
 190         /*
 191          * loop over the definition list and extract the information we need.
 192          */
 193         foreach(pl, parameters)
 194         {
 195                 DefElem    *defel = (DefElem *) lfirst(pl);
 196
 197                 if (pg_strcasecmp(defel->defname, "start") == 0)
 198                 {
 199                         values[Anum_pg_ts_parser_prsstart - 1] =
 200                                 get_ts_parser_func(defel, Anum_pg_ts_parser_prsstart);
 201                 }
 202                 else if (pg_strcasecmp(defel->defname, "gettoken") == 0)
 203                 {
 204                         values[Anum_pg_ts_parser_prstoken - 1] =
 205                                 get_ts_parser_func(defel, Anum_pg_ts_parser_prstoken);
 206                 }
 207                 else if (pg_strcasecmp(defel->defname, "end") == 0)
 208                 {
 209                         values[Anum_pg_ts_parser_prsend - 1] =
 210                                 get_ts_parser_func(defel, Anum_pg_ts_parser_prsend);
 211                 }
 212                 else if (pg_strcasecmp(defel->defname, "headline") == 0)
 213                 {
 214                         values[Anum_pg_ts_parser_prsheadline - 1] =
 215                                 get_ts_parser_func(defel, Anum_pg_ts_parser_prsheadline);
 216                 }
 217                 else if (pg_strcasecmp(defel->defname, "lextypes") == 0)
 218                 {
 219                         values[Anum_pg_ts_parser_prslextype - 1] =
 220                                 get_ts_parser_func(defel, Anum_pg_ts_parser_prslextype);
 221                 }
 222                 else
 223                         ereport(ERROR,
 224                                         (errcode(ERRCODE_SYNTAX_ERROR),
 225                                  errmsg("text search parser parameter \"%s\" not recognized",
 226                                                 defel->defname)));
 227         }
 228
 229         /*
 230          * Validation
 231          */
 232         if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prsstart - 1])))
 233                 ereport(ERROR,
 234                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 235                                  errmsg("text search parser start method is required")));
 236
 237         if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prstoken - 1])))
 238                 ereport(ERROR,
 239                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 240                                  errmsg("text search parser gettoken method is required")));
 241
 242         if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prsend - 1])))
 243                 ereport(ERROR,
 244                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 245                                  errmsg("text search parser end method is required")));
 246
 247         if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_parser_prslextype - 1])))
 248                 ereport(ERROR,
 249                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 250                                  errmsg("text search parser lextypes method is required")));
 251
 252         /*
 253          * Looks good, insert
 254          */
 255         prsRel = heap_open(TSParserRelationId, RowExclusiveLock);
 256
 257         tup = heap_formtuple(prsRel->rd_att, values, nulls);
 258
 259         prsOid = simple_heap_insert(prsRel, tup);
 260
 261         CatalogUpdateIndexes(prsRel, tup);
 262
 263         makeParserDependencies(tup);
 264
 265         heap_freetuple(tup);
 266
 267         heap_close(prsRel, RowExclusiveLock);
 268 }
 269
 270 /*
 271  * DROP TEXT SEARCH PARSER
 272  */
 273 void
 274 RemoveTSParsers(DropStmt *drop)
 275 {
 276         ObjectAddresses *objects;
 277         ListCell                *cell;
 278
 279         if (!superuser())
 280                 ereport(ERROR,
 281                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 282                                  errmsg("must be superuser to drop text search parsers")));
 283
 284         /*
 285          * First we identify all the objects, then we delete them in a single
 286          * performMultipleDeletions() call.  This is to avoid unwanted
 287          * DROP RESTRICT errors if one of the objects depends on another.
 288          */
 289         objects = new_object_addresses();
 290
 291         foreach(cell, drop->objects)
 292         {
 293                 List            *names = (List *) lfirst(cell);
 294                 Oid                     prsOid;
 295                 ObjectAddress object;
 296
 297                 prsOid = TSParserGetPrsid(names, true);
 298
 299                 if (!OidIsValid(prsOid))
 300                 {
 301                         if (!drop->missing_ok)
 302                         {
 303                                 ereport(ERROR,
 304                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 305                                                  errmsg("text search parser \"%s\" does not exist",
 306                                                                 NameListToString(names))));
 307                         }
 308                         else
 309                         {
 310                                 ereport(NOTICE,
 311                                         (errmsg("text search parser \"%s\" does not exist, skipping",
 312                                                         NameListToString(names))));
 313                         }
 314                         continue;
 315                 }
 316
 317                 object.classId = TSParserRelationId;
 318                 object.objectId = prsOid;
 319                 object.objectSubId = 0;
 320
 321                 add_exact_object_address(&object, objects);
 322         }
 323
 324         performMultipleDeletions(objects, drop->behavior);
 325
 326         free_object_addresses(objects);
 327 }
 328
 329 /*
 330  * Guts of TS parser deletion.
 331  */
 332 void
 333 RemoveTSParserById(Oid prsId)
 334 {
 335         Relation        relation;
 336         HeapTuple       tup;
 337
 338         relation = heap_open(TSParserRelationId, RowExclusiveLock);
 339
 340         tup = SearchSysCache(TSPARSEROID,
 341                                                  ObjectIdGetDatum(prsId),
 342                                                  0, 0, 0);
 343
 344         if (!HeapTupleIsValid(tup))
 345                 elog(ERROR, "cache lookup failed for text search parser %u", prsId);
 346
 347         simple_heap_delete(relation, &tup->t_self);
 348
 349         ReleaseSysCache(tup);
 350
 351         heap_close(relation, RowExclusiveLock);
 352 }
 353
 354 /*
 355  * ALTER TEXT SEARCH PARSER RENAME
 356  */
 357 void
 358 RenameTSParser(List *oldname, const char *newname)
 359 {
 360         HeapTuple       tup;
 361         Relation        rel;
 362         Oid                     prsId;
 363         Oid                     namespaceOid;
 364
 365         if (!superuser())
 366                 ereport(ERROR,
 367                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 368                                  errmsg("must be superuser to rename text search parsers")));
 369
 370         rel = heap_open(TSParserRelationId, RowExclusiveLock);
 371
 372         prsId = TSParserGetPrsid(oldname, false);
 373
 374         tup = SearchSysCacheCopy(TSPARSEROID,
 375                                                          ObjectIdGetDatum(prsId),
 376                                                          0, 0, 0);
 377
 378         if (!HeapTupleIsValid(tup)) /* should not happen */
 379                 elog(ERROR, "cache lookup failed for text search parser %u", prsId);
 380
 381         namespaceOid = ((Form_pg_ts_parser) GETSTRUCT(tup))->prsnamespace;
 382
 383         if (SearchSysCacheExists(TSPARSERNAMENSP,
 384                                                          PointerGetDatum(newname),
 385                                                          ObjectIdGetDatum(namespaceOid),
 386                                                          0, 0))
 387                 ereport(ERROR,
 388                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 389                                  errmsg("text search parser \"%s\" already exists",
 390                                                 newname)));
 391
 392         namestrcpy(&(((Form_pg_ts_parser) GETSTRUCT(tup))->prsname), newname);
 393         simple_heap_update(rel, &tup->t_self, tup);
 394         CatalogUpdateIndexes(rel, tup);
 395
 396         heap_close(rel, NoLock);
 397         heap_freetuple(tup);
 398 }
 399
 400 /* ---------------------- TS Dictionary commands -----------------------*/
 401
 402 /*
 403  * make pg_depend entries for a new pg_ts_dict entry
 404  */
 405 static void
 406 makeDictionaryDependencies(HeapTuple tuple)
 407 {
 408         Form_pg_ts_dict dict = (Form_pg_ts_dict) GETSTRUCT(tuple);
 409         ObjectAddress myself,
 410                                 referenced;
 411
 412         myself.classId = TSDictionaryRelationId;
 413         myself.objectId = HeapTupleGetOid(tuple);
 414         myself.objectSubId = 0;
 415
 416         /* dependency on namespace */
 417         referenced.classId = NamespaceRelationId;
 418         referenced.objectId = dict->dictnamespace;
 419         referenced.objectSubId = 0;
 420         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 421
 422         /* dependency on owner */
 423         recordDependencyOnOwner(myself.classId, myself.objectId, dict->dictowner);
 424
 425         /* dependency on template */
 426         referenced.classId = TSTemplateRelationId;
 427         referenced.objectId = dict->dicttemplate;
 428         referenced.objectSubId = 0;
 429         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 430 }
 431
 432 /*
 433  * verify that a template's init method accepts a proposed option list
 434  */
 435 static void
 436 verify_dictoptions(Oid tmplId, List *dictoptions)
 437 {
 438         HeapTuple       tup;
 439         Form_pg_ts_template tform;
 440         Oid                     initmethod;
 441
 442         /*
 443          * Suppress this test when running in a standalone backend.  This is a
 444          * hack to allow initdb to create prefab dictionaries that might not
 445          * actually be usable in template1's encoding (due to using external files
 446          * that can't be translated into template1's encoding).  We want to create
 447          * them anyway, since they might be usable later in other databases.
 448          */
 449         if (!IsUnderPostmaster)
 450                 return;
 451
 452         tup = SearchSysCache(TSTEMPLATEOID,
 453                                                  ObjectIdGetDatum(tmplId),
 454                                                  0, 0, 0);
 455         if (!HeapTupleIsValid(tup)) /* should not happen */
 456                 elog(ERROR, "cache lookup failed for text search template %u",
 457                          tmplId);
 458         tform = (Form_pg_ts_template) GETSTRUCT(tup);
 459
 460         initmethod = tform->tmplinit;
 461
 462         if (!OidIsValid(initmethod))
 463         {
 464                 /* If there is no init method, disallow any options */
 465                 if (dictoptions)
 466                         ereport(ERROR,
 467                                         (errcode(ERRCODE_SYNTAX_ERROR),
 468                                 errmsg("text search template \"%s\" does not accept options",
 469                                            NameStr(tform->tmplname))));
 470         }
 471         else
 472         {
 473                 /*
 474                  * Copy the options just in case init method thinks it can scribble on
 475                  * them ...
 476                  */
 477                 dictoptions = copyObject(dictoptions);
 478
 479                 /*
 480                  * Call the init method and see if it complains.  We don't worry about
 481                  * it leaking memory, since our command will soon be over anyway.
 482                  */
 483                 (void) OidFunctionCall1(initmethod, PointerGetDatum(dictoptions));
 484         }
 485
 486         ReleaseSysCache(tup);
 487 }
 488
 489 /*
 490  * CREATE TEXT SEARCH DICTIONARY
 491  */
 492 void
 493 DefineTSDictionary(List *names, List *parameters)
 494 {
 495         ListCell   *pl;
 496         Relation        dictRel;
 497         HeapTuple       tup;
 498         Datum           values[Natts_pg_ts_dict];
 499         char            nulls[Natts_pg_ts_dict];
 500         NameData        dname;
 501         Oid                     templId = InvalidOid;
 502         List       *dictoptions = NIL;
 503         Oid                     dictOid;
 504         Oid                     namespaceoid;
 505         AclResult       aclresult;
 506         char       *dictname;
 507
 508         /* Convert list of names to a name and namespace */
 509         namespaceoid = QualifiedNameGetCreationNamespace(names, &dictname);
 510
 511         /* Check we have creation rights in target namespace */
 512         aclresult = pg_namespace_aclcheck(namespaceoid, GetUserId(), ACL_CREATE);
 513         if (aclresult != ACLCHECK_OK)
 514                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 515                                            get_namespace_name(namespaceoid));
 516
 517         /*
 518          * loop over the definition list and extract the information we need.
 519          */
 520         foreach(pl, parameters)
 521         {
 522                 DefElem    *defel = (DefElem *) lfirst(pl);
 523
 524                 if (pg_strcasecmp(defel->defname, "template") == 0)
 525                 {
 526                         templId = TSTemplateGetTmplid(defGetQualifiedName(defel), false);
 527                 }
 528                 else
 529                 {
 530                         /* Assume it's an option for the dictionary itself */
 531                         dictoptions = lappend(dictoptions, defel);
 532                 }
 533         }
 534
 535         /*
 536          * Validation
 537          */
 538         if (!OidIsValid(templId))
 539                 ereport(ERROR,
 540                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 541                                  errmsg("text search template is required")));
 542
 543         verify_dictoptions(templId, dictoptions);
 544
 545         /*
 546          * Looks good, insert
 547          */
 548         memset(values, 0, sizeof(values));
 549         memset(nulls, ' ', sizeof(nulls));
 550
 551         namestrcpy(&dname, dictname);
 552         values[Anum_pg_ts_dict_dictname - 1] = NameGetDatum(&dname);
 553         values[Anum_pg_ts_dict_dictnamespace - 1] = ObjectIdGetDatum(namespaceoid);
 554         values[Anum_pg_ts_dict_dictowner - 1] = ObjectIdGetDatum(GetUserId());
 555         values[Anum_pg_ts_dict_dicttemplate - 1] = ObjectIdGetDatum(templId);
 556         if (dictoptions)
 557                 values[Anum_pg_ts_dict_dictinitoption - 1] =
 558                         PointerGetDatum(serialize_deflist(dictoptions));
 559         else
 560                 nulls[Anum_pg_ts_dict_dictinitoption - 1] = 'n';
 561
 562         dictRel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 563
 564         tup = heap_formtuple(dictRel->rd_att, values, nulls);
 565
 566         dictOid = simple_heap_insert(dictRel, tup);
 567
 568         CatalogUpdateIndexes(dictRel, tup);
 569
 570         makeDictionaryDependencies(tup);
 571
 572         heap_freetuple(tup);
 573
 574         heap_close(dictRel, RowExclusiveLock);
 575 }
 576
 577 /*
 578  * ALTER TEXT SEARCH DICTIONARY RENAME
 579  */
 580 void
 581 RenameTSDictionary(List *oldname, const char *newname)
 582 {
 583         HeapTuple       tup;
 584         Relation        rel;
 585         Oid                     dictId;
 586         Oid                     namespaceOid;
 587         AclResult       aclresult;
 588
 589         rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 590
 591         dictId = TSDictionaryGetDictid(oldname, false);
 592
 593         tup = SearchSysCacheCopy(TSDICTOID,
 594                                                          ObjectIdGetDatum(dictId),
 595                                                          0, 0, 0);
 596
 597         if (!HeapTupleIsValid(tup)) /* should not happen */
 598                 elog(ERROR, "cache lookup failed for text search dictionary %u",
 599                          dictId);
 600
 601         namespaceOid = ((Form_pg_ts_dict) GETSTRUCT(tup))->dictnamespace;
 602
 603         if (SearchSysCacheExists(TSDICTNAMENSP,
 604                                                          PointerGetDatum(newname),
 605                                                          ObjectIdGetDatum(namespaceOid),
 606                                                          0, 0))
 607                 ereport(ERROR,
 608                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 609                                  errmsg("text search dictionary \"%s\" already exists",
 610                                                 newname)));
 611
 612         /* must be owner */
 613         if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
 614                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
 615                                            NameListToString(oldname));
 616
 617         /* must have CREATE privilege on namespace */
 618         aclresult = pg_namespace_aclcheck(namespaceOid, GetUserId(), ACL_CREATE);
 619         if (aclresult != ACLCHECK_OK)
 620                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 621                                            get_namespace_name(namespaceOid));
 622
 623         namestrcpy(&(((Form_pg_ts_dict) GETSTRUCT(tup))->dictname), newname);
 624         simple_heap_update(rel, &tup->t_self, tup);
 625         CatalogUpdateIndexes(rel, tup);
 626
 627         heap_close(rel, NoLock);
 628         heap_freetuple(tup);
 629 }
 630
 631 /*
 632  * DROP TEXT SEARCH DICTIONARY
 633  */
 634 void
 635 RemoveTSDictionaries(DropStmt *drop)
 636 {
 637         ObjectAddresses *objects;
 638         ListCell                *cell;
 639
 640         /*
 641          * First we identify all the objects, then we delete them in a single
 642          * performMultipleDeletions() call.  This is to avoid unwanted
 643          * DROP RESTRICT errors if one of the objects depends on another.
 644          */
 645         objects = new_object_addresses();
 646
 647         foreach(cell, drop->objects)
 648         {
 649                 List            *names = (List *) lfirst(cell);
 650                 Oid                     dictOid;
 651                 ObjectAddress object;
 652                 HeapTuple       tup;
 653                 Oid                     namespaceId;
 654
 655                 dictOid = TSDictionaryGetDictid(names, true);
 656
 657                 if (!OidIsValid(dictOid))
 658                 {
 659                         if (!drop->missing_ok)
 660                         {
 661                                 ereport(ERROR,
 662                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 663                                                  errmsg("text search dictionary \"%s\" does not exist",
 664                                                                 NameListToString(names))));
 665                         }
 666                         else
 667                         {
 668                                 ereport(NOTICE,
 669                                 (errmsg("text search dictionary \"%s\" does not exist, skipping",
 670                                                 NameListToString(names))));
 671                         }
 672                         continue;
 673                 }
 674
 675                 tup = SearchSysCache(TSDICTOID,
 676                                                          ObjectIdGetDatum(dictOid),
 677                                                          0, 0, 0);
 678                 if (!HeapTupleIsValid(tup)) /* should not happen */
 679                         elog(ERROR, "cache lookup failed for text search dictionary %u",
 680                                  dictOid);
 681
 682                 /* Permission check: must own dictionary or its namespace */
 683                 namespaceId = ((Form_pg_ts_dict) GETSTRUCT(tup))->dictnamespace;
 684                 if (!pg_ts_dict_ownercheck(dictOid, GetUserId()) &&
 685                         !pg_namespace_ownercheck(namespaceId, GetUserId()))
 686                         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
 687                                                    NameListToString(names));
 688
 689                 object.classId = TSDictionaryRelationId;
 690                 object.objectId = dictOid;
 691                 object.objectSubId = 0;
 692
 693                 add_exact_object_address(&object, objects);
 694
 695                 ReleaseSysCache(tup);
 696         }
 697
 698         performMultipleDeletions(objects, drop->behavior);
 699
 700         free_object_addresses(objects);
 701 }
 702
 703 /*
 704  * Guts of TS dictionary deletion.
 705  */
 706 void
 707 RemoveTSDictionaryById(Oid dictId)
 708 {
 709         Relation        relation;
 710         HeapTuple       tup;
 711
 712         relation = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 713
 714         tup = SearchSysCache(TSDICTOID,
 715                                                  ObjectIdGetDatum(dictId),
 716                                                  0, 0, 0);
 717
 718         if (!HeapTupleIsValid(tup))
 719                 elog(ERROR, "cache lookup failed for text search dictionary %u",
 720                          dictId);
 721
 722         simple_heap_delete(relation, &tup->t_self);
 723
 724         ReleaseSysCache(tup);
 725
 726         heap_close(relation, RowExclusiveLock);
 727 }
 728
 729 /*
 730  * ALTER TEXT SEARCH DICTIONARY
 731  */
 732 void
 733 AlterTSDictionary(AlterTSDictionaryStmt *stmt)
 734 {
 735         HeapTuple       tup,
 736                                 newtup;
 737         Relation        rel;
 738         Oid                     dictId;
 739         ListCell   *pl;
 740         List       *dictoptions;
 741         Datum           opt;
 742         bool            isnull;
 743         Datum           repl_val[Natts_pg_ts_dict];
 744         char            repl_null[Natts_pg_ts_dict];
 745         char            repl_repl[Natts_pg_ts_dict];
 746
 747         dictId = TSDictionaryGetDictid(stmt->dictname, false);
 748
 749         rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 750
 751         tup = SearchSysCache(TSDICTOID,
 752                                                  ObjectIdGetDatum(dictId),
 753                                                  0, 0, 0);
 754
 755         if (!HeapTupleIsValid(tup))
 756                 elog(ERROR, "cache lookup failed for text search dictionary %u",
 757                          dictId);
 758
 759         /* must be owner */
 760         if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
 761                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
 762                                            NameListToString(stmt->dictname));
 763
 764         /* deserialize the existing set of options */
 765         opt = SysCacheGetAttr(TSDICTOID, tup,
 766                                                   Anum_pg_ts_dict_dictinitoption,
 767                                                   &isnull);
 768         if (isnull)
 769                 dictoptions = NIL;
 770         else
 771                 dictoptions = deserialize_deflist(opt);
 772
 773         /*
 774          * Modify the options list as per specified changes
 775          */
 776         foreach(pl, stmt->options)
 777         {
 778                 DefElem    *defel = (DefElem *) lfirst(pl);
 779                 ListCell   *cell;
 780                 ListCell   *prev;
 781                 ListCell   *next;
 782
 783                 /*
 784                  * Remove any matches ...
 785                  */
 786                 prev = NULL;
 787                 for (cell = list_head(dictoptions); cell; cell = next)
 788                 {
 789                         DefElem    *oldel = (DefElem *) lfirst(cell);
 790
 791                         next = lnext(cell);
 792                         if (pg_strcasecmp(oldel->defname, defel->defname) == 0)
 793                                 dictoptions = list_delete_cell(dictoptions, cell, prev);
 794                         else
 795                                 prev = cell;
 796                 }
 797
 798                 /*
 799                  * and add new value if it's got one
 800                  */
 801                 if (defel->arg)
 802                         dictoptions = lappend(dictoptions, defel);
 803         }
 804
 805         /*
 806          * Validate
 807          */
 808         verify_dictoptions(((Form_pg_ts_dict) GETSTRUCT(tup))->dicttemplate,
 809                                            dictoptions);
 810
 811         /*
 812          * Looks good, update
 813          */
 814         memset(repl_val, 0, sizeof(repl_val));
 815         memset(repl_null, ' ', sizeof(repl_null));
 816         memset(repl_repl, ' ', sizeof(repl_repl));
 817
 818         if (dictoptions)
 819                 repl_val[Anum_pg_ts_dict_dictinitoption - 1] =
 820                         PointerGetDatum(serialize_deflist(dictoptions));
 821         else
 822                 repl_null[Anum_pg_ts_dict_dictinitoption - 1] = 'n';
 823         repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = 'r';
 824
 825         newtup = heap_modifytuple(tup, RelationGetDescr(rel),
 826                                                           repl_val, repl_null, repl_repl);
 827
 828         simple_heap_update(rel, &newtup->t_self, newtup);
 829
 830         CatalogUpdateIndexes(rel, newtup);
 831
 832         /*
 833          * NOTE: because we only support altering the options, not the template,
 834          * there is no need to update dependencies.  This might have to change if
 835          * the options ever reference inside-the-database objects.
 836          */
 837
 838         heap_freetuple(newtup);
 839         ReleaseSysCache(tup);
 840
 841         heap_close(rel, RowExclusiveLock);
 842 }
 843
 844 /*
 845  * ALTER TEXT SEARCH DICTIONARY OWNER
 846  */
 847 void
 848 AlterTSDictionaryOwner(List *name, Oid newOwnerId)
 849 {
 850         HeapTuple       tup;
 851         Relation        rel;
 852         Oid                     dictId;
 853         Oid                     namespaceOid;
 854         AclResult       aclresult;
 855         Form_pg_ts_dict form;
 856
 857         rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 858
 859         dictId = TSDictionaryGetDictid(name, false);
 860
 861         tup = SearchSysCacheCopy(TSDICTOID,
 862                                                          ObjectIdGetDatum(dictId),
 863                                                          0, 0, 0);
 864
 865         if (!HeapTupleIsValid(tup)) /* should not happen */
 866                 elog(ERROR, "cache lookup failed for text search dictionary %u",
 867                          dictId);
 868
 869         form = (Form_pg_ts_dict) GETSTRUCT(tup);
 870         namespaceOid = form->dictnamespace;
 871
 872         if (form->dictowner != newOwnerId)
 873         {
 874                 /* Superusers can always do it */
 875                 if (!superuser())
 876                 {
 877                         /* must be owner */
 878                         if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
 879                                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
 880                                                            NameListToString(name));
 881
 882                         /* Must be able to become new owner */
 883                         check_is_member_of_role(GetUserId(), newOwnerId);
 884
 885                         /* New owner must have CREATE privilege on namespace */
 886                         aclresult = pg_namespace_aclcheck(namespaceOid, newOwnerId, ACL_CREATE);
 887                         if (aclresult != ACLCHECK_OK)
 888                                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 889                                                            get_namespace_name(namespaceOid));
 890                 }
 891
 892                 form->dictowner = newOwnerId;
 893
 894                 simple_heap_update(rel, &tup->t_self, tup);
 895                 CatalogUpdateIndexes(rel, tup);
 896
 897                 /* Update owner dependency reference */
 898                 changeDependencyOnOwner(TSDictionaryRelationId, HeapTupleGetOid(tup),
 899                                                                 newOwnerId);
 900         }
 901
 902         heap_close(rel, NoLock);
 903         heap_freetuple(tup);
 904 }
 905
 906 /* ---------------------- TS Template commands -----------------------*/
 907
 908 /*
 909  * lookup a template support function and return its OID (as a Datum)
 910  *
 911  * attnum is the pg_ts_template column the function will go into
 912  */
 913 static Datum
 914 get_ts_template_func(DefElem *defel, int attnum)
 915 {
 916         List       *funcName = defGetQualifiedName(defel);
 917         Oid                     typeId[4];
 918         Oid                     retTypeId;
 919         int                     nargs;
 920         Oid                     procOid;
 921
 922         retTypeId = INTERNALOID;
 923         typeId[0] = INTERNALOID;
 924         typeId[1] = INTERNALOID;
 925         typeId[2] = INTERNALOID;
 926         typeId[3] = INTERNALOID;
 927         switch (attnum)
 928         {
 929                 case Anum_pg_ts_template_tmplinit:
 930                         nargs = 1;
 931                         break;
 932                 case Anum_pg_ts_template_tmpllexize:
 933                         nargs = 4;
 934                         break;
 935                 default:
 936                         /* should not be here */
 937                         elog(ERROR, "unrecognized attribute for text search template: %d",
 938                                  attnum);
 939                         nargs = 0;                      /* keep compiler quiet */
 940         }
 941
 942         procOid = LookupFuncName(funcName, nargs, typeId, false);
 943         if (get_func_rettype(procOid) != retTypeId)
 944                 ereport(ERROR,
 945                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
 946                                  errmsg("function %s should return type %s",
 947                                                 func_signature_string(funcName, nargs, typeId),
 948                                                 format_type_be(retTypeId))));
 949
 950         return ObjectIdGetDatum(procOid);
 951 }
 952
 953 /*
 954  * make pg_depend entries for a new pg_ts_template entry
 955  */
 956 static void
 957 makeTSTemplateDependencies(HeapTuple tuple)
 958 {
 959         Form_pg_ts_template tmpl = (Form_pg_ts_template) GETSTRUCT(tuple);
 960         ObjectAddress myself,
 961                                 referenced;
 962
 963         myself.classId = TSTemplateRelationId;
 964         myself.objectId = HeapTupleGetOid(tuple);
 965         myself.objectSubId = 0;
 966
 967         /* dependency on namespace */
 968         referenced.classId = NamespaceRelationId;
 969         referenced.objectId = tmpl->tmplnamespace;
 970         referenced.objectSubId = 0;
 971         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 972
 973         /* dependencies on functions */
 974         referenced.classId = ProcedureRelationId;
 975         referenced.objectSubId = 0;
 976
 977         referenced.objectId = tmpl->tmpllexize;
 978         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 979
 980         if (OidIsValid(tmpl->tmplinit))
 981         {
 982                 referenced.objectId = tmpl->tmplinit;
 983                 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 984         }
 985 }
 986
 987 /*
 988  * CREATE TEXT SEARCH TEMPLATE
 989  */
 990 void
 991 DefineTSTemplate(List *names, List *parameters)
 992 {
 993         ListCell   *pl;
 994         Relation        tmplRel;
 995         HeapTuple       tup;
 996         Datum           values[Natts_pg_ts_template];
 997         char            nulls[Natts_pg_ts_template];
 998         NameData        dname;
 999         int                     i;
1000         Oid                     dictOid;
1001         Oid                     namespaceoid;
1002         char       *tmplname;
1003
1004         if (!superuser())
1005                 ereport(ERROR,
1006                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1007                            errmsg("must be superuser to create text search templates")));
1008
1009         /* Convert list of names to a name and namespace */
1010         namespaceoid = QualifiedNameGetCreationNamespace(names, &tmplname);
1011
1012         for (i = 0; i < Natts_pg_ts_template; i++)
1013         {
1014                 nulls[i] = ' ';
1015                 values[i] = ObjectIdGetDatum(InvalidOid);
1016         }
1017
1018         namestrcpy(&dname, tmplname);
1019         values[Anum_pg_ts_template_tmplname - 1] = NameGetDatum(&dname);
1020         values[Anum_pg_ts_template_tmplnamespace - 1] = ObjectIdGetDatum(namespaceoid);
1021
1022         /*
1023          * loop over the definition list and extract the information we need.
1024          */
1025         foreach(pl, parameters)
1026         {
1027                 DefElem    *defel = (DefElem *) lfirst(pl);
1028
1029                 if (pg_strcasecmp(defel->defname, "init") == 0)
1030                 {
1031                         values[Anum_pg_ts_template_tmplinit - 1] =
1032                                 get_ts_template_func(defel, Anum_pg_ts_template_tmplinit);
1033                         nulls[Anum_pg_ts_template_tmplinit - 1] = ' ';
1034                 }
1035                 else if (pg_strcasecmp(defel->defname, "lexize") == 0)
1036                 {
1037                         values[Anum_pg_ts_template_tmpllexize - 1] =
1038                                 get_ts_template_func(defel, Anum_pg_ts_template_tmpllexize);
1039                         nulls[Anum_pg_ts_template_tmpllexize - 1] = ' ';
1040                 }
1041                 else
1042                         ereport(ERROR,
1043                                         (errcode(ERRCODE_SYNTAX_ERROR),
1044                            errmsg("text search template parameter \"%s\" not recognized",
1045                                           defel->defname)));
1046         }
1047
1048         /*
1049          * Validation
1050          */
1051         if (!OidIsValid(DatumGetObjectId(values[Anum_pg_ts_template_tmpllexize - 1])))
1052                 ereport(ERROR,
1053                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1054                                  errmsg("text search template lexize method is required")));
1055
1056         /*
1057          * Looks good, insert
1058          */
1059
1060         tmplRel = heap_open(TSTemplateRelationId, RowExclusiveLock);
1061
1062         tup = heap_formtuple(tmplRel->rd_att, values, nulls);
1063
1064         dictOid = simple_heap_insert(tmplRel, tup);
1065
1066         CatalogUpdateIndexes(tmplRel, tup);
1067
1068         makeTSTemplateDependencies(tup);
1069
1070         heap_freetuple(tup);
1071
1072         heap_close(tmplRel, RowExclusiveLock);
1073 }
1074
1075 /*
1076  * ALTER TEXT SEARCH TEMPLATE RENAME
1077  */
1078 void
1079 RenameTSTemplate(List *oldname, const char *newname)
1080 {
1081         HeapTuple       tup;
1082         Relation        rel;
1083         Oid                     tmplId;
1084         Oid                     namespaceOid;
1085
1086         if (!superuser())
1087                 ereport(ERROR,
1088                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1089                            errmsg("must be superuser to rename text search templates")));
1090
1091         rel = heap_open(TSTemplateRelationId, RowExclusiveLock);
1092
1093         tmplId = TSTemplateGetTmplid(oldname, false);
1094
1095         tup = SearchSysCacheCopy(TSTEMPLATEOID,
1096                                                          ObjectIdGetDatum(tmplId),
1097                                                          0, 0, 0);
1098
1099         if (!HeapTupleIsValid(tup)) /* should not happen */
1100                 elog(ERROR, "cache lookup failed for text search template %u",
1101                          tmplId);
1102
1103         namespaceOid = ((Form_pg_ts_template) GETSTRUCT(tup))->tmplnamespace;
1104
1105         if (SearchSysCacheExists(TSTEMPLATENAMENSP,
1106                                                          PointerGetDatum(newname),
1107                                                          ObjectIdGetDatum(namespaceOid),
1108                                                          0, 0))
1109                 ereport(ERROR,
1110                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
1111                                  errmsg("text search template \"%s\" already exists",
1112                                                 newname)));
1113
1114         namestrcpy(&(((Form_pg_ts_template) GETSTRUCT(tup))->tmplname), newname);
1115         simple_heap_update(rel, &tup->t_self, tup);
1116         CatalogUpdateIndexes(rel, tup);
1117
1118         heap_close(rel, NoLock);
1119         heap_freetuple(tup);
1120 }
1121
1122 /*
1123  * DROP TEXT SEARCH TEMPLATE
1124  */
1125 void
1126 RemoveTSTemplates(DropStmt *drop)
1127 {
1128         ObjectAddresses *objects;
1129         ListCell                *cell;
1130
1131         if (!superuser())
1132                 ereport(ERROR,
1133                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1134                                  errmsg("must be superuser to drop text search templates")));
1135
1136         /*
1137          * First we identify all the objects, then we delete them in a single
1138          * performMultipleDeletions() call.  This is to avoid unwanted
1139          * DROP RESTRICT errors if one of the objects depends on another.
1140          */
1141         objects = new_object_addresses();
1142
1143         foreach(cell, drop->objects)
1144         {
1145                 List            *names = (List *) lfirst(cell);
1146                 Oid                     tmplOid;
1147                 ObjectAddress object;
1148
1149                 tmplOid = TSTemplateGetTmplid(names, true);
1150
1151                 if (!OidIsValid(tmplOid))
1152                 {
1153                         if (!drop->missing_ok)
1154                         {
1155                                 ereport(ERROR,
1156                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
1157                                                  errmsg("text search template \"%s\" does not exist",
1158                                                                 NameListToString(names))));
1159                         }
1160                         else
1161                         {
1162                                 ereport(NOTICE,
1163                                                 (errmsg("text search template \"%s\" does not exist, skipping",
1164                                                                 NameListToString(names))));
1165                         }
1166                         continue;
1167                 }
1168
1169                 object.classId = TSTemplateRelationId;
1170                 object.objectId = tmplOid;
1171                 object.objectSubId = 0;
1172
1173                 add_exact_object_address(&object, objects);
1174         }
1175
1176         performMultipleDeletions(objects, drop->behavior);
1177
1178         free_object_addresses(objects);
1179 }
1180
1181 /*
1182  * Guts of TS template deletion.
1183  */
1184 void
1185 RemoveTSTemplateById(Oid tmplId)
1186 {
1187         Relation        relation;
1188         HeapTuple       tup;
1189
1190         relation = heap_open(TSTemplateRelationId, RowExclusiveLock);
1191
1192         tup = SearchSysCache(TSTEMPLATEOID,
1193                                                  ObjectIdGetDatum(tmplId),
1194                                                  0, 0, 0);
1195
1196         if (!HeapTupleIsValid(tup))
1197                 elog(ERROR, "cache lookup failed for text search template %u",
1198                          tmplId);
1199
1200         simple_heap_delete(relation, &tup->t_self);
1201
1202         ReleaseSysCache(tup);
1203
1204         heap_close(relation, RowExclusiveLock);
1205 }
1206
1207 /* ---------------------- TS Configuration commands -----------------------*/
1208
1209 /*
1210  * Finds syscache tuple of configuration.
1211  * Returns NULL if no such cfg.
1212  */
1213 static HeapTuple
1214 GetTSConfigTuple(List *names)
1215 {
1216         HeapTuple       tup;
1217         Oid                     cfgId;
1218
1219         cfgId = TSConfigGetCfgid(names, true);
1220         if (!OidIsValid(cfgId))
1221                 return NULL;
1222
1223         tup = SearchSysCache(TSCONFIGOID,
1224                                                  ObjectIdGetDatum(cfgId),
1225                                                  0, 0, 0);
1226
1227         if (!HeapTupleIsValid(tup)) /* should not happen */
1228                 elog(ERROR, "cache lookup failed for text search configuration %u",
1229                          cfgId);
1230
1231         return tup;
1232 }
1233
1234 /*
1235  * make pg_depend entries for a new or updated pg_ts_config entry
1236  *
1237  * Pass opened pg_ts_config_map relation if there might be any config map
1238  * entries for the config.
1239  */
1240 static void
1241 makeConfigurationDependencies(HeapTuple tuple, bool removeOld,
1242                                                           Relation mapRel)
1243 {
1244         Form_pg_ts_config cfg = (Form_pg_ts_config) GETSTRUCT(tuple);
1245         ObjectAddresses *addrs;
1246         ObjectAddress myself,
1247                                 referenced;
1248
1249         myself.classId = TSConfigRelationId;
1250         myself.objectId = HeapTupleGetOid(tuple);
1251         myself.objectSubId = 0;
1252
1253         /* for ALTER case, first flush old dependencies */
1254         if (removeOld)
1255         {
1256                 deleteDependencyRecordsFor(myself.classId, myself.objectId);
1257                 deleteSharedDependencyRecordsFor(myself.classId, myself.objectId);
1258         }
1259
1260         /*
1261          * We use an ObjectAddresses list to remove possible duplicate
1262          * dependencies from the config map info.  The pg_ts_config items
1263          * shouldn't be duplicates, but might as well fold them all into one call.
1264          */
1265         addrs = new_object_addresses();
1266
1267         /* dependency on namespace */
1268         referenced.classId = NamespaceRelationId;
1269         referenced.objectId = cfg->cfgnamespace;
1270         referenced.objectSubId = 0;
1271         add_exact_object_address(&referenced, addrs);
1272
1273         /* dependency on owner */
1274         recordDependencyOnOwner(myself.classId, myself.objectId, cfg->cfgowner);
1275
1276         /* dependency on parser */
1277         referenced.classId = TSParserRelationId;
1278         referenced.objectId = cfg->cfgparser;
1279         referenced.objectSubId = 0;
1280         add_exact_object_address(&referenced, addrs);
1281
1282         /* dependencies on dictionaries listed in config map */
1283         if (mapRel)
1284         {
1285                 ScanKeyData skey;
1286                 SysScanDesc scan;
1287                 HeapTuple       maptup;
1288
1289                 /* CCI to ensure we can see effects of caller's changes */
1290                 CommandCounterIncrement();
1291
1292                 ScanKeyInit(&skey,
1293                                         Anum_pg_ts_config_map_mapcfg,
1294                                         BTEqualStrategyNumber, F_OIDEQ,
1295                                         ObjectIdGetDatum(myself.objectId));
1296
1297                 scan = systable_beginscan(mapRel, TSConfigMapIndexId, true,
1298                                                                   SnapshotNow, 1, &skey);
1299
1300                 while (HeapTupleIsValid((maptup = systable_getnext(scan))))
1301                 {
1302                         Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);
1303
1304                         referenced.classId = TSDictionaryRelationId;
1305                         referenced.objectId = cfgmap->mapdict;
1306                         referenced.objectSubId = 0;
1307                         add_exact_object_address(&referenced, addrs);
1308                 }
1309
1310                 systable_endscan(scan);
1311         }
1312
1313         /* Record 'em (this includes duplicate elimination) */
1314         record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
1315
1316         free_object_addresses(addrs);
1317 }
1318
1319 /*
1320  * CREATE TEXT SEARCH CONFIGURATION
1321  */
1322 void
1323 DefineTSConfiguration(List *names, List *parameters)
1324 {
1325         Relation        cfgRel;
1326         Relation        mapRel = NULL;
1327         HeapTuple       tup;
1328         Datum           values[Natts_pg_ts_config];
1329         char            nulls[Natts_pg_ts_config];
1330         AclResult       aclresult;
1331         Oid                     namespaceoid;
1332         char       *cfgname;
1333         NameData        cname;
1334         Oid                     sourceOid = InvalidOid;
1335         Oid                     prsOid = InvalidOid;
1336         Oid                     cfgOid;
1337         ListCell   *pl;
1338
1339         /* Convert list of names to a name and namespace */
1340         namespaceoid = QualifiedNameGetCreationNamespace(names, &cfgname);
1341
1342         /* Check we have creation rights in target namespace */
1343         aclresult = pg_namespace_aclcheck(namespaceoid, GetUserId(), ACL_CREATE);
1344         if (aclresult != ACLCHECK_OK)
1345                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
1346                                            get_namespace_name(namespaceoid));
1347
1348         /*
1349          * loop over the definition list and extract the information we need.
1350          */
1351         foreach(pl, parameters)
1352         {
1353                 DefElem    *defel = (DefElem *) lfirst(pl);
1354
1355                 if (pg_strcasecmp(defel->defname, "parser") == 0)
1356                         prsOid = TSParserGetPrsid(defGetQualifiedName(defel), false);
1357                 else if (pg_strcasecmp(defel->defname, "copy") == 0)
1358                         sourceOid = TSConfigGetCfgid(defGetQualifiedName(defel), false);
1359                 else
1360                         ereport(ERROR,
1361                                         (errcode(ERRCODE_SYNTAX_ERROR),
1362                                          errmsg("text search configuration parameter \"%s\" not recognized",
1363                                                         defel->defname)));
1364         }
1365
1366         if (OidIsValid(sourceOid) && OidIsValid(prsOid))
1367                 ereport(ERROR,
1368                                 (errcode(ERRCODE_SYNTAX_ERROR),
1369                                  errmsg("cannot specify both PARSER and COPY options")));
1370
1371         /*
1372          * Look up source config if given.
1373          */
1374         if (OidIsValid(sourceOid))
1375         {
1376                 Form_pg_ts_config cfg;
1377
1378                 tup = SearchSysCache(TSCONFIGOID,
1379                                                          ObjectIdGetDatum(sourceOid),
1380                                                          0, 0, 0);
1381                 if (!HeapTupleIsValid(tup))
1382                         elog(ERROR, "cache lookup failed for text search configuration %u",
1383                                  sourceOid);
1384
1385                 cfg = (Form_pg_ts_config) GETSTRUCT(tup);
1386
1387                 /* use source's parser */
1388                 prsOid = cfg->cfgparser;
1389
1390                 ReleaseSysCache(tup);
1391         }
1392
1393         /*
1394          * Validation
1395          */
1396         if (!OidIsValid(prsOid))
1397                 ereport(ERROR,
1398                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1399                                  errmsg("text search parser is required")));
1400
1401         /*
1402          * Looks good, build tuple and insert
1403          */
1404         memset(values, 0, sizeof(values));
1405         memset(nulls, ' ', sizeof(nulls));
1406
1407         namestrcpy(&cname, cfgname);
1408         values[Anum_pg_ts_config_cfgname - 1] = NameGetDatum(&cname);
1409         values[Anum_pg_ts_config_cfgnamespace - 1] = ObjectIdGetDatum(namespaceoid);
1410         values[Anum_pg_ts_config_cfgowner - 1] = ObjectIdGetDatum(GetUserId());
1411         values[Anum_pg_ts_config_cfgparser - 1] = ObjectIdGetDatum(prsOid);
1412
1413         cfgRel = heap_open(TSConfigRelationId, RowExclusiveLock);
1414
1415         tup = heap_formtuple(cfgRel->rd_att, values, nulls);
1416
1417         cfgOid = simple_heap_insert(cfgRel, tup);
1418
1419         CatalogUpdateIndexes(cfgRel, tup);
1420
1421         if (OidIsValid(sourceOid))
1422         {
1423                 /*
1424                  * Copy token-dicts map from source config
1425                  */
1426                 ScanKeyData skey;
1427                 SysScanDesc scan;
1428                 HeapTuple       maptup;
1429
1430                 mapRel = heap_open(TSConfigMapRelationId, RowExclusiveLock);
1431
1432                 ScanKeyInit(&skey,
1433                                         Anum_pg_ts_config_map_mapcfg,
1434                                         BTEqualStrategyNumber, F_OIDEQ,
1435                                         ObjectIdGetDatum(sourceOid));
1436
1437                 scan = systable_beginscan(mapRel, TSConfigMapIndexId, true,
1438                                                                   SnapshotNow, 1, &skey);
1439
1440                 while (HeapTupleIsValid((maptup = systable_getnext(scan))))
1441                 {
1442                         Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);
1443                         HeapTuple       newmaptup;
1444                         Datum           mapvalues[Natts_pg_ts_config_map];
1445                         char            mapnulls[Natts_pg_ts_config_map];
1446
1447                         memset(mapvalues, 0, sizeof(mapvalues));
1448                         memset(mapnulls, ' ', sizeof(mapnulls));
1449
1450                         mapvalues[Anum_pg_ts_config_map_mapcfg - 1] = cfgOid;
1451                         mapvalues[Anum_pg_ts_config_map_maptokentype - 1] = cfgmap->maptokentype;
1452                         mapvalues[Anum_pg_ts_config_map_mapseqno - 1] = cfgmap->mapseqno;
1453                         mapvalues[Anum_pg_ts_config_map_mapdict - 1] = cfgmap->mapdict;
1454
1455                         newmaptup = heap_formtuple(mapRel->rd_att, mapvalues, mapnulls);
1456
1457                         simple_heap_insert(mapRel, newmaptup);
1458
1459                         CatalogUpdateIndexes(mapRel, newmaptup);
1460
1461                         heap_freetuple(newmaptup);
1462                 }
1463
1464                 systable_endscan(scan);
1465         }
1466
1467         makeConfigurationDependencies(tup, false, mapRel);
1468
1469         heap_freetuple(tup);
1470
1471         if (mapRel)
1472                 heap_close(mapRel, RowExclusiveLock);
1473         heap_close(cfgRel, RowExclusiveLock);
1474 }
1475
1476 /*
1477  * ALTER TEXT SEARCH CONFIGURATION RENAME
1478  */
1479 void
1480 RenameTSConfiguration(List *oldname, const char *newname)
1481 {
1482         HeapTuple       tup;
1483         Relation        rel;
1484         Oid                     cfgId;
1485         AclResult       aclresult;
1486         Oid                     namespaceOid;
1487
1488         rel = heap_open(TSConfigRelationId, RowExclusiveLock);
1489
1490         cfgId = TSConfigGetCfgid(oldname, false);
1491
1492         tup = SearchSysCacheCopy(TSCONFIGOID,
1493                                                          ObjectIdGetDatum(cfgId),
1494                                                          0, 0, 0);
1495
1496         if (!HeapTupleIsValid(tup)) /* should not happen */
1497                 elog(ERROR, "cache lookup failed for text search configuration %u",
1498                          cfgId);
1499
1500         namespaceOid = ((Form_pg_ts_config) GETSTRUCT(tup))->cfgnamespace;
1501
1502         if (SearchSysCacheExists(TSCONFIGNAMENSP,
1503                                                          PointerGetDatum(newname),
1504                                                          ObjectIdGetDatum(namespaceOid),
1505                                                          0, 0))
1506                 ereport(ERROR,
1507                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
1508                                  errmsg("text search configuration \"%s\" already exists",
1509                                                 newname)));
1510
1511         /* must be owner */
1512         if (!pg_ts_config_ownercheck(cfgId, GetUserId()))
1513                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
1514                                            NameListToString(oldname));
1515
1516         /* must have CREATE privilege on namespace */
1517         aclresult = pg_namespace_aclcheck(namespaceOid, GetUserId(), ACL_CREATE);
1518         aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
1519                                    get_namespace_name(namespaceOid));
1520
1521         namestrcpy(&(((Form_pg_ts_config) GETSTRUCT(tup))->cfgname), newname);
1522         simple_heap_update(rel, &tup->t_self, tup);
1523         CatalogUpdateIndexes(rel, tup);
1524
1525         heap_close(rel, NoLock);
1526         heap_freetuple(tup);
1527 }
1528
1529 /*
1530  * DROP TEXT SEARCH CONFIGURATION
1531  */
1532 void
1533 RemoveTSConfigurations(DropStmt *drop)
1534 {
1535         ObjectAddresses *objects;
1536         ListCell                *cell;
1537
1538         /*
1539          * First we identify all the objects, then we delete them in a single
1540          * performMultipleDeletions() call.  This is to avoid unwanted
1541          * DROP RESTRICT errors if one of the objects depends on another.
1542          */
1543         objects = new_object_addresses();
1544
1545         foreach(cell, drop->objects)
1546         {
1547                 List            *names = (List *) lfirst(cell);
1548                 Oid                     cfgOid;
1549                 Oid                     namespaceId;
1550                 ObjectAddress object;
1551                 HeapTuple       tup;
1552
1553                 tup = GetTSConfigTuple(names);
1554
1555                 if (!HeapTupleIsValid(tup))
1556                 {
1557                         if (!drop->missing_ok)
1558                         {
1559                                 ereport(ERROR,
1560                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
1561                                                  errmsg("text search configuration \"%s\" does not exist",
1562                                                                 NameListToString(names))));
1563                         }
1564                         else
1565                         {
1566                                 ereport(NOTICE,
1567                                                 (errmsg("text search configuration \"%s\" does not exist, skipping",
1568                                                                 NameListToString(names))));
1569                         }
1570                         continue;
1571                 }
1572
1573                 /* Permission check: must own configuration or its namespace */
1574                 cfgOid = HeapTupleGetOid(tup);
1575                 namespaceId = ((Form_pg_ts_config) GETSTRUCT(tup))->cfgnamespace;
1576                 if (!pg_ts_config_ownercheck(cfgOid, GetUserId()) &&
1577                         !pg_namespace_ownercheck(namespaceId, GetUserId()))
1578                         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
1579                                                    NameListToString(names));
1580
1581                 object.classId = TSConfigRelationId;
1582                 object.objectId = cfgOid;
1583                 object.objectSubId = 0;
1584
1585                 add_exact_object_address(&object, objects);
1586
1587                 ReleaseSysCache(tup);
1588         }
1589
1590         performMultipleDeletions(objects, drop->behavior);
1591
1592         free_object_addresses(objects);
1593 }
1594
1595 /*
1596  * Guts of TS configuration deletion.
1597  */
1598 void
1599 RemoveTSConfigurationById(Oid cfgId)
1600 {
1601         Relation        relCfg,
1602                                 relMap;
1603         HeapTuple       tup;
1604         ScanKeyData skey;
1605         SysScanDesc scan;
1606
1607         /* Remove the pg_ts_config entry */
1608         relCfg = heap_open(TSConfigRelationId, RowExclusiveLock);
1609
1610         tup = SearchSysCache(TSCONFIGOID,
1611                                                  ObjectIdGetDatum(cfgId),
1612                                                  0, 0, 0);
1613
1614         if (!HeapTupleIsValid(tup))
1615                 elog(ERROR, "cache lookup failed for text search dictionary %u",
1616                          cfgId);
1617
1618         simple_heap_delete(relCfg, &tup->t_self);
1619
1620         ReleaseSysCache(tup);
1621
1622         heap_close(relCfg, RowExclusiveLock);
1623
1624         /* Remove any pg_ts_config_map entries */
1625         relMap = heap_open(TSConfigMapRelationId, RowExclusiveLock);
1626
1627         ScanKeyInit(&skey,
1628                                 Anum_pg_ts_config_map_mapcfg,
1629                                 BTEqualStrategyNumber, F_OIDEQ,
1630                                 ObjectIdGetDatum(cfgId));
1631
1632         scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
1633                                                           SnapshotNow, 1, &skey);
1634
1635         while (HeapTupleIsValid((tup = systable_getnext(scan))))
1636         {
1637                 simple_heap_delete(relMap, &tup->t_self);
1638         }
1639
1640         systable_endscan(scan);
1641
1642         heap_close(relMap, RowExclusiveLock);
1643 }
1644
1645 /*
1646  * ALTER TEXT SEARCH CONFIGURATION OWNER
1647  */
1648 void
1649 AlterTSConfigurationOwner(List *name, Oid newOwnerId)
1650 {
1651         HeapTuple       tup;
1652         Relation        rel;
1653         Oid                     cfgId;
1654         AclResult       aclresult;
1655         Oid                     namespaceOid;
1656         Form_pg_ts_config form;
1657
1658         rel = heap_open(TSConfigRelationId, RowExclusiveLock);
1659
1660         cfgId = TSConfigGetCfgid(name, false);
1661
1662         tup = SearchSysCacheCopy(TSCONFIGOID,
1663                                                          ObjectIdGetDatum(cfgId),
1664                                                          0, 0, 0);
1665
1666         if (!HeapTupleIsValid(tup)) /* should not happen */
1667                 elog(ERROR, "cache lookup failed for text search configuration %u",
1668                          cfgId);
1669
1670         form = (Form_pg_ts_config) GETSTRUCT(tup);
1671         namespaceOid = form->cfgnamespace;
1672
1673         if (form->cfgowner != newOwnerId)
1674         {
1675                 /* Superusers can always do it */
1676                 if (!superuser())
1677                 {
1678                         /* must be owner */
1679                         if (!pg_ts_config_ownercheck(cfgId, GetUserId()))
1680                                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
1681                                                            NameListToString(name));
1682
1683                         /* Must be able to become new owner */
1684                         check_is_member_of_role(GetUserId(), newOwnerId);
1685
1686                         /* New owner must have CREATE privilege on namespace */
1687                         aclresult = pg_namespace_aclcheck(namespaceOid, newOwnerId, ACL_CREATE);
1688                         if (aclresult != ACLCHECK_OK)
1689                                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
1690                                                            get_namespace_name(namespaceOid));
1691                 }
1692
1693                 form->cfgowner = newOwnerId;
1694
1695                 simple_heap_update(rel, &tup->t_self, tup);
1696                 CatalogUpdateIndexes(rel, tup);
1697
1698                 /* Update owner dependency reference */
1699                 changeDependencyOnOwner(TSConfigRelationId, HeapTupleGetOid(tup),
1700                                                                 newOwnerId);
1701         }
1702
1703         heap_close(rel, NoLock);
1704         heap_freetuple(tup);
1705 }
1706
1707 /*
1708  * ALTER TEXT SEARCH CONFIGURATION - main entry point
1709  */
1710 void
1711 AlterTSConfiguration(AlterTSConfigurationStmt *stmt)
1712 {
1713         HeapTuple       tup;
1714         Relation        relMap;
1715
1716         /* Find the configuration */
1717         tup = GetTSConfigTuple(stmt->cfgname);
1718         if (!HeapTupleIsValid(tup))
1719                 ereport(ERROR,
1720                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
1721                                  errmsg("text search configuration \"%s\" does not exist",
1722                                                 NameListToString(stmt->cfgname))));
1723
1724         /* must be owner */
1725         if (!pg_ts_config_ownercheck(HeapTupleGetOid(tup), GetUserId()))
1726                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
1727                                            NameListToString(stmt->cfgname));
1728
1729         relMap = heap_open(TSConfigMapRelationId, RowExclusiveLock);
1730
1731         /* Add or drop mappings */
1732         if (stmt->dicts)
1733                 MakeConfigurationMapping(stmt, tup, relMap);
1734         else if (stmt->tokentype)
1735                 DropConfigurationMapping(stmt, tup, relMap);
1736
1737         /* Update dependencies */
1738         makeConfigurationDependencies(tup, true, relMap);
1739
1740         heap_close(relMap, RowExclusiveLock);
1741
1742         ReleaseSysCache(tup);
1743 }
1744
1745 /*
1746  * Translate a list of token type names to an array of token type numbers
1747  */
1748 static int *
1749 getTokenTypes(Oid prsId, List *tokennames)
1750 {
1751         TSParserCacheEntry *prs = lookup_ts_parser_cache(prsId);
1752         LexDescr   *list;
1753         int                *res,
1754                                 i,
1755                                 ntoken;
1756         ListCell   *tn;
1757
1758         ntoken = list_length(tokennames);
1759         if (ntoken == 0)
1760                 return NULL;
1761         res = (int *) palloc(sizeof(int) * ntoken);
1762
1763         if (!OidIsValid(prs->lextypeOid))
1764                 elog(ERROR, "method lextype isn't defined for text search parser %u",
1765                          prsId);
1766
1767         /* OidFunctionCall0 is absent */
1768         list = (LexDescr *) DatumGetPointer(OidFunctionCall1(prs->lextypeOid,
1769                                                                                                                  (Datum) 0));
1770
1771         i = 0;
1772         foreach(tn, tokennames)
1773         {
1774                 Value      *val = (Value *) lfirst(tn);
1775                 bool            found = false;
1776                 int                     j;
1777
1778                 j = 0;
1779                 while (list && list[j].lexid)
1780                 {
1781                         /* XXX should we use pg_strcasecmp here? */
1782                         if (strcmp(strVal(val), list[j].alias) == 0)
1783                         {
1784                                 res[i] = list[j].lexid;
1785                                 found = true;
1786                                 break;
1787                         }
1788                         j++;
1789                 }
1790                 if (!found)
1791                         ereport(ERROR,
1792                                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1793                                          errmsg("token type \"%s\" does not exist",
1794                                                         strVal(val))));
1795                 i++;
1796         }
1797
1798         return res;
1799 }
1800
1801 /*
1802  * ALTER TEXT SEARCH CONFIGURATION ADD/ALTER MAPPING
1803  */
1804 static void
1805 MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
1806                                                  HeapTuple tup, Relation relMap)
1807 {
1808         Oid                     cfgId = HeapTupleGetOid(tup);
1809         ScanKeyData skey[2];
1810         SysScanDesc scan;
1811         HeapTuple       maptup;
1812         int                     i;
1813         int                     j;
1814         Oid                     prsId;
1815         int                *tokens,
1816                                 ntoken;
1817         Oid                *dictIds;
1818         int                     ndict;
1819         ListCell   *c;
1820
1821         prsId = ((Form_pg_ts_config) GETSTRUCT(tup))->cfgparser;
1822
1823         tokens = getTokenTypes(prsId, stmt->tokentype);
1824         ntoken = list_length(stmt->tokentype);
1825
1826         if (stmt->override)
1827         {
1828                 /*
1829                  * delete maps for tokens if they exist and command was ALTER
1830                  */
1831                 for (i = 0; i < ntoken; i++)
1832                 {
1833                         ScanKeyInit(&skey[0],
1834                                                 Anum_pg_ts_config_map_mapcfg,
1835                                                 BTEqualStrategyNumber, F_OIDEQ,
1836                                                 ObjectIdGetDatum(cfgId));
1837                         ScanKeyInit(&skey[1],
1838                                                 Anum_pg_ts_config_map_maptokentype,
1839                                                 BTEqualStrategyNumber, F_INT4EQ,
1840                                                 Int32GetDatum(tokens[i]));
1841
1842                         scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
1843                                                                           SnapshotNow, 2, skey);
1844
1845                         while (HeapTupleIsValid((maptup = systable_getnext(scan))))
1846                         {
1847                                 simple_heap_delete(relMap, &maptup->t_self);
1848                         }
1849
1850                         systable_endscan(scan);
1851                 }
1852         }
1853
1854         /*
1855          * Convert list of dictionary names to array of dict OIDs
1856          */
1857         ndict = list_length(stmt->dicts);
1858         dictIds = (Oid *) palloc(sizeof(Oid) * ndict);
1859         i = 0;
1860         foreach(c, stmt->dicts)
1861         {
1862                 List       *names = (List *) lfirst(c);
1863
1864                 dictIds[i] = TSDictionaryGetDictid(names, false);
1865                 i++;
1866         }
1867
1868         if (stmt->replace)
1869         {
1870                 /*
1871                  * Replace a specific dictionary in existing entries
1872                  */
1873                 Oid                     dictOld = dictIds[0],
1874                                         dictNew = dictIds[1];
1875
1876                 ScanKeyInit(&skey[0],
1877                                         Anum_pg_ts_config_map_mapcfg,
1878                                         BTEqualStrategyNumber, F_OIDEQ,
1879                                         ObjectIdGetDatum(cfgId));
1880
1881                 scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
1882                                                                   SnapshotNow, 1, skey);
1883
1884                 while (HeapTupleIsValid((maptup = systable_getnext(scan))))
1885                 {
1886                         Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);
1887
1888                         /*
1889                          * check if it's one of target token types
1890                          */
1891                         if (tokens)
1892                         {
1893                                 bool            tokmatch = false;
1894
1895                                 for (j = 0; j < ntoken; j++)
1896                                 {
1897                                         if (cfgmap->maptokentype == tokens[j])
1898                                         {
1899                                                 tokmatch = true;
1900                                                 break;
1901                                         }
1902                                 }
1903                                 if (!tokmatch)
1904                                         continue;
1905                         }
1906
1907                         /*
1908                          * replace dictionary if match
1909                          */
1910                         if (cfgmap->mapdict == dictOld)
1911                         {
1912                                 Datum           repl_val[Natts_pg_ts_config_map];
1913                                 char            repl_null[Natts_pg_ts_config_map];
1914                                 char            repl_repl[Natts_pg_ts_config_map];
1915                                 HeapTuple       newtup;
1916
1917                                 memset(repl_val, 0, sizeof(repl_val));
1918                                 memset(repl_null, ' ', sizeof(repl_null));
1919                                 memset(repl_repl, ' ', sizeof(repl_repl));
1920
1921                                 repl_val[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictNew);
1922                                 repl_repl[Anum_pg_ts_config_map_mapdict - 1] = 'r';
1923
1924                                 newtup = heap_modifytuple(maptup,
1925                                                                                   RelationGetDescr(relMap),
1926                                                                                   repl_val, repl_null, repl_repl);
1927                                 simple_heap_update(relMap, &newtup->t_self, newtup);
1928
1929                                 CatalogUpdateIndexes(relMap, newtup);
1930                         }
1931                 }
1932
1933                 systable_endscan(scan);
1934         }
1935         else
1936         {
1937                 /*
1938                  * Insertion of new entries
1939                  */
1940                 for (i = 0; i < ntoken; i++)
1941                 {
1942                         for (j = 0; j < ndict; j++)
1943                         {
1944                                 Datum           values[Natts_pg_ts_config_map];
1945                                 char            nulls[Natts_pg_ts_config_map];
1946
1947                                 memset(nulls, ' ', sizeof(nulls));
1948                                 values[Anum_pg_ts_config_map_mapcfg - 1] = ObjectIdGetDatum(cfgId);
1949                                 values[Anum_pg_ts_config_map_maptokentype - 1] = Int32GetDatum(tokens[i]);
1950                                 values[Anum_pg_ts_config_map_mapseqno - 1] = Int32GetDatum(j + 1);
1951                                 values[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictIds[j]);
1952
1953                                 tup = heap_formtuple(relMap->rd_att, values, nulls);
1954                                 simple_heap_insert(relMap, tup);
1955                                 CatalogUpdateIndexes(relMap, tup);
1956
1957                                 heap_freetuple(tup);
1958                         }
1959                 }
1960         }
1961 }
1962
1963 /*
1964  * ALTER TEXT SEARCH CONFIGURATION DROP MAPPING
1965  */
1966 static void
1967 DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
1968                                                  HeapTuple tup, Relation relMap)
1969 {
1970         Oid                     cfgId = HeapTupleGetOid(tup);
1971         ScanKeyData skey[2];
1972         SysScanDesc scan;
1973         HeapTuple       maptup;
1974         int                     i;
1975         Oid                     prsId;
1976         int                *tokens,
1977                                 ntoken;
1978         ListCell   *c;
1979
1980         prsId = ((Form_pg_ts_config) GETSTRUCT(tup))->cfgparser;
1981
1982         tokens = getTokenTypes(prsId, stmt->tokentype);
1983         ntoken = list_length(stmt->tokentype);
1984
1985         i = 0;
1986         foreach(c, stmt->tokentype)
1987         {
1988                 Value      *val = (Value *) lfirst(c);
1989                 bool            found = false;
1990
1991                 ScanKeyInit(&skey[0],
1992                                         Anum_pg_ts_config_map_mapcfg,
1993                                         BTEqualStrategyNumber, F_OIDEQ,
1994                                         ObjectIdGetDatum(cfgId));
1995                 ScanKeyInit(&skey[1],
1996                                         Anum_pg_ts_config_map_maptokentype,
1997                                         BTEqualStrategyNumber, F_INT4EQ,
1998                                         Int32GetDatum(tokens[i]));
1999
2000                 scan = systable_beginscan(relMap, TSConfigMapIndexId, true,
2001                                                                   SnapshotNow, 2, skey);
2002
2003                 while (HeapTupleIsValid((maptup = systable_getnext(scan))))
2004                 {
2005                         simple_heap_delete(relMap, &maptup->t_self);
2006                         found = true;
2007                 }
2008
2009                 systable_endscan(scan);
2010
2011                 if (!found)
2012                 {
2013                         if (!stmt->missing_ok)
2014                         {
2015                                 ereport(ERROR,
2016                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
2017                                            errmsg("mapping for token type \"%s\" does not exist",
2018                                                           strVal(val))));
2019                         }
2020                         else
2021                         {
2022                                 ereport(NOTICE,
2023                                                 (errmsg("mapping for token type \"%s\" does not exist, skipping",
2024                                                                 strVal(val))));
2025                         }
2026                 }
2027
2028                 i++;
2029         }
2030 }
2031
2032
2033 /*
2034  * Serialize dictionary options, producing a TEXT datum from a List of DefElem
2035  *
2036  * This is used to form the value stored in pg_ts_dict.dictinitoption.
2037  * For the convenience of pg_dump, the output is formatted exactly as it
2038  * would need to appear in CREATE TEXT SEARCH DICTIONARY to reproduce the
2039  * same options.
2040  *
2041  * Note that we assume that only the textual representation of an option's
2042  * value is interesting --- hence, non-string DefElems get forced to strings.
2043  */
2044 text *
2045 serialize_deflist(List *deflist)
2046 {
2047         text       *result;
2048         StringInfoData buf;
2049         ListCell   *l;
2050
2051         initStringInfo(&buf);
2052
2053         foreach(l, deflist)
2054         {
2055                 DefElem    *defel = (DefElem *) lfirst(l);
2056                 char       *val = defGetString(defel);
2057
2058                 appendStringInfo(&buf, "%s = ",
2059                                                  quote_identifier(defel->defname));
2060                 /* If backslashes appear, force E syntax to determine their handling */
2061                 if (strchr(val, '\\'))
2062                         appendStringInfoChar(&buf, ESCAPE_STRING_SYNTAX);
2063                 appendStringInfoChar(&buf, '\'');
2064                 while (*val)
2065                 {
2066                         char            ch = *val++;
2067
2068                         if (SQL_STR_DOUBLE(ch, true))
2069                                 appendStringInfoChar(&buf, ch);
2070                         appendStringInfoChar(&buf, ch);
2071                 }
2072                 appendStringInfoChar(&buf, '\'');
2073                 if (lnext(l) != NULL)
2074                         appendStringInfo(&buf, ", ");
2075         }
2076
2077         result = cstring_to_text_with_len(buf.data, buf.len);
2078         pfree(buf.data);
2079         return result;
2080 }
2081
2082 /*
2083  * Deserialize dictionary options, reconstructing a List of DefElem from TEXT
2084  *
2085  * This is also used for prsheadline options, so for backward compatibility
2086  * we need to accept a few things serialize_deflist() will never emit:
2087  * in particular, unquoted and double-quoted values.
2088  */
2089 List *
2090 deserialize_deflist(Datum txt)
2091 {
2092         text       *in = DatumGetTextP(txt);            /* in case it's toasted */
2093         List       *result = NIL;
2094         int                     len = VARSIZE(in) - VARHDRSZ;
2095         char       *ptr,
2096                            *endptr,
2097                            *workspace,
2098                            *wsptr = NULL,
2099                            *startvalue = NULL;
2100         typedef enum
2101         {
2102                 CS_WAITKEY,
2103                 CS_INKEY,
2104                 CS_INQKEY,
2105                 CS_WAITEQ,
2106                 CS_WAITVALUE,
2107                 CS_INSQVALUE,
2108                 CS_INDQVALUE,
2109                 CS_INWVALUE
2110         } ds_state;
2111         ds_state        state = CS_WAITKEY;
2112
2113         workspace = (char *) palloc(len + 1);           /* certainly enough room */
2114         ptr = VARDATA(in);
2115         endptr = ptr + len;
2116         for (; ptr < endptr; ptr++)
2117         {
2118                 switch (state)
2119                 {
2120                         case CS_WAITKEY:
2121                                 if (isspace((unsigned char) *ptr) || *ptr == ',')
2122                                         continue;
2123                                 if (*ptr == '"')
2124                                 {
2125                                         wsptr = workspace;
2126                                         state = CS_INQKEY;
2127                                 }
2128                                 else
2129                                 {
2130                                         wsptr = workspace;
2131                                         *wsptr++ = *ptr;
2132                                         state = CS_INKEY;
2133                                 }
2134                                 break;
2135                         case CS_INKEY:
2136                                 if (isspace((unsigned char) *ptr))
2137                                 {
2138                                         *wsptr++ = '\0';
2139                                         state = CS_WAITEQ;
2140                                 }
2141                                 else if (*ptr == '=')
2142                                 {
2143                                         *wsptr++ = '\0';
2144                                         state = CS_WAITVALUE;
2145                                 }
2146                                 else
2147                                 {
2148                                         *wsptr++ = *ptr;
2149                                 }
2150                                 break;
2151                         case CS_INQKEY:
2152                                 if (*ptr == '"')
2153                                 {
2154                                         if (ptr + 1 < endptr && ptr[1] == '"')
2155                                         {
2156                                                 /* copy only one of the two quotes */
2157                                                 *wsptr++ = *ptr++;
2158                                         }
2159                                         else
2160                                         {
2161                                                 *wsptr++ = '\0';
2162                                                 state = CS_WAITEQ;
2163                                         }
2164                                 }
2165                                 else
2166                                 {
2167                                         *wsptr++ = *ptr;
2168                                 }
2169                                 break;
2170                         case CS_WAITEQ:
2171                                 if (*ptr == '=')
2172                                         state = CS_WAITVALUE;
2173                                 else if (!isspace((unsigned char) *ptr))
2174                                         ereport(ERROR,
2175                                                         (errcode(ERRCODE_SYNTAX_ERROR),
2176                                                          errmsg("invalid parameter list format: \"%s\"",
2177                                                                         text_to_cstring(in))));
2178                                 break;
2179                         case CS_WAITVALUE:
2180                                 if (*ptr == '\'')
2181                                 {
2182                                         startvalue = wsptr;
2183                                         state = CS_INSQVALUE;
2184                                 }
2185                                 else if (*ptr == 'E' && ptr + 1 < endptr && ptr[1] == '\'')
2186                                 {
2187                                         ptr++;
2188                                         startvalue = wsptr;
2189                                         state = CS_INSQVALUE;
2190                                 }
2191                                 else if (*ptr == '"')
2192                                 {
2193                                         startvalue = wsptr;
2194                                         state = CS_INDQVALUE;
2195                                 }
2196                                 else if (!isspace((unsigned char) *ptr))
2197                                 {
2198                                         startvalue = wsptr;
2199                                         *wsptr++ = *ptr;
2200                                         state = CS_INWVALUE;
2201                                 }
2202                                 break;
2203                         case CS_INSQVALUE:
2204                                 if (*ptr == '\'')
2205                                 {
2206                                         if (ptr + 1 < endptr && ptr[1] == '\'')
2207                                         {
2208                                                 /* copy only one of the two quotes */
2209                                                 *wsptr++ = *ptr++;
2210                                         }
2211                                         else
2212                                         {
2213                                                 *wsptr++ = '\0';
2214                                                 result = lappend(result,
2215                                                                                  makeDefElem(pstrdup(workspace),
2216                                                                   (Node *) makeString(pstrdup(startvalue))));
2217                                                 state = CS_WAITKEY;
2218                                         }
2219                                 }
2220                                 else if (*ptr == '\\')
2221                                 {
2222                                         if (ptr + 1 < endptr && ptr[1] == '\\')
2223                                         {
2224                                                 /* copy only one of the two backslashes */
2225                                                 *wsptr++ = *ptr++;
2226                                         }
2227                                         else
2228                                                 *wsptr++ = *ptr;
2229                                 }
2230                                 else
2231                                 {
2232                                         *wsptr++ = *ptr;
2233                                 }
2234                                 break;
2235                         case CS_INDQVALUE:
2236                                 if (*ptr == '"')
2237                                 {
2238                                         if (ptr + 1 < endptr && ptr[1] == '"')
2239                                         {
2240                                                 /* copy only one of the two quotes */
2241                                                 *wsptr++ = *ptr++;
2242                                         }
2243                                         else
2244                                         {
2245                                                 *wsptr++ = '\0';
2246                                                 result = lappend(result,
2247                                                                                  makeDefElem(pstrdup(workspace),
2248                                                                   (Node *) makeString(pstrdup(startvalue))));
2249                                                 state = CS_WAITKEY;
2250                                         }
2251                                 }
2252                                 else
2253                                 {
2254                                         *wsptr++ = *ptr;
2255                                 }
2256                                 break;
2257                         case CS_INWVALUE:
2258                                 if (*ptr == ',' || isspace((unsigned char) *ptr))
2259                                 {
2260                                         *wsptr++ = '\0';
2261                                         result = lappend(result,
2262                                                                          makeDefElem(pstrdup(workspace),
2263                                                                   (Node *) makeString(pstrdup(startvalue))));
2264                                         state = CS_WAITKEY;
2265                                 }
2266                                 else
2267                                 {
2268                                         *wsptr++ = *ptr;
2269                                 }
2270                                 break;
2271                         default:
2272                                 elog(ERROR, "unrecognized deserialize_deflist state: %d",
2273                                          state);
2274                 }
2275         }
2276
2277         if (state == CS_INWVALUE)
2278         {
2279                 *wsptr++ = '\0';
2280                 result = lappend(result,
2281                                                  makeDefElem(pstrdup(workspace),
2282                                                                   (Node *) makeString(pstrdup(startvalue))));
2283         }
2284         else if (state != CS_WAITKEY)
2285                 ereport(ERROR,
2286                                 (errcode(ERRCODE_SYNTAX_ERROR),
2287                                  errmsg("invalid parameter list format: \"%s\"",
2288                                                 text_to_cstring(in))));
2289
2290         pfree(workspace);
2291
2292         return result;
2293 }