<!--

$PostgreSQL: pgsql/doc/src/sgml/ref/alter_tsconfig.sgml,v 1.1 2007/08/21 21:08:47 tgl Exp $

$PostgreSQL: pgsql/doc/src/sgml/ref/alter_tsconfig.sgml,v 1.2 2007/08/22 05:13:50 tgl Exp $

PostgreSQL documentation

-->

<refsynopsisdiv>

<synopsis>

ALTER TEXT SEARCH CONFIGURATION <replaceable>name</replaceable> (

PARSER = <replaceable class="parameter">parser_name</replaceable>

)

ALTER TEXT SEARCH CONFIGURATION <replaceable>name</replaceable>

ADD MAPPING FOR <replaceable class="parameter">token_type</replaceable> [, ... ] WITH <replaceable class="parameter">dictionary_name</replaceable> [, ... ]

ALTER TEXT SEARCH CONFIGURATION <replaceable>name</replaceable>

<para>

<command>ALTER TEXT SEARCH CONFIGURATION</command> changes the definition of

a text search configuration. You canchange which parser it uses,modify

itsmapping from token types to dictionaries,

a text search configuration. You can modify

itsmappings from token types to dictionaries,

or change the configuration's name or owner.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><replaceable class="parameter">parser_name</replaceable></term>

<listitem>

<para>

The name of a new text search parser to use for this configuration.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><replaceable class="parameter">token_type</replaceable></term>

<listitem>

</para>

</refsect1>

<refsect1>

<title>Notes</title>

<para>

While changing the text search parser used by a configuration is allowed,

this will only work nicely if old and new parsers use the same set of

token types. It is advisable to drop the mappings for any incompatible

token types before changing parsers.

</para>

</refsect1>

<refsect1>

<title>Examples</title>

<!--

$PostgreSQL: pgsql/doc/src/sgml/ref/create_tsconfig.sgml,v 1.1 2007/08/21 21:08:47 tgl Exp $

$PostgreSQL: pgsql/doc/src/sgml/ref/create_tsconfig.sgml,v 1.2 2007/08/22 05:13:50 tgl Exp $

PostgreSQL documentation

-->

<title>Notes</title>

<para>

It is allowed to specify both <literal>PARSER</> and <literal>COPY</>,

resulting in the specified parser being used with whatever mappings

are in the source configuration. This is generally inadvisable,

unless you know that both parsers involved use the same token type set.

The <literal>PARSER</> and <literal>COPY</> options are mutually

exclusive, because when an existing configuration is copied, its

parser selection is copied too.

</para>

</refsect1>

staticHeapTupleUpdateTSConfiguration(AlterTSConfigurationStmt*stmt,

HeapTupletup);

staticvoidMakeConfigurationMapping(AlterTSConfigurationStmt*stmt,

HeapTupletup);

HeapTupletup,RelationrelMap);

staticvoidDropConfigurationMapping(AlterTSConfigurationStmt*stmt,

HeapTupletup);

HeapTupletup,RelationrelMap);

Oidnamespaceoid;

char*cfgname;

NameDatacname;

List*sourceName=NIL;

OidsourceOid=InvalidOid;

OidprsOid=InvalidOid;

OidcfgOid;

if (pg_strcasecmp(defel->defname,"parser")==0)

prsOid=TSParserGetPrsid(defGetQualifiedName(defel), false);

elseif (pg_strcasecmp(defel->defname,"copy")==0)

sourceName=defGetQualifiedName(defel);

sourceOid=TSConfigGetCfgid(defGetQualifiedName(defel), false);

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

errmsg("text search configuration parameter \"%s\" not recognized",

defel->defname)));

}

if (OidIsValid(sourceOid)&&OidIsValid(prsOid))

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

errmsg("cannot specify both PARSER and COPY options")));

if (sourceName)

if (OidIsValid(sourceOid))

{

Form_pg_ts_configcfg;

sourceOid=TSConfigGetCfgid(sourceName, false);

tup=SearchSysCache(TSCONFIGOID,

ObjectIdGetDatum(sourceOid),

0,0,0);

cfg= (Form_pg_ts_config)GETSTRUCT(tup);

if (!OidIsValid(prsOid))

prsOid=cfg->cfgparser;

prsOid=cfg->cfgparser;

ReleaseSysCache(tup);

}

AlterTSConfiguration(AlterTSConfigurationStmt*stmt)

{

HeapTupletup;

HeapTuplenewtup;

RelationmapRel;

RelationrelMap;

tup=GetTSConfigTuple(stmt->cfgname);

aclcheck_error(ACLCHECK_NOT_OWNER,ACL_KIND_TSCONFIGURATION,

NameListToString(stmt->cfgname));

if (stmt->options)

newtup=UpdateTSConfiguration(stmt,tup);

newtup=tup;

relMap=heap_open(TSConfigMapRelationId,RowExclusiveLock);

if (stmt->dicts)

MakeConfigurationMapping(stmt,newtup);

MakeConfigurationMapping(stmt,tup,relMap);

elseif (stmt->tokentype)

DropConfigurationMapping(stmt,newtup);

mapRel=heap_open(TSConfigMapRelationId,AccessShareLock);

DropConfigurationMapping(stmt,tup,relMap);

makeConfigurationDependencies(newtup, true,mapRel);

makeConfigurationDependencies(tup, true,relMap);

heap_close(mapRel,AccessShareLock);

heap_close(relMap,RowExclusiveLock);

ReleaseSysCache(tup);

}

UpdateTSConfiguration(AlterTSConfigurationStmt*stmt,HeapTupletup)

{

RelationcfgRel;

ListCell*pl;

Datumrepl_val[Natts_pg_ts_config];

charrepl_null[Natts_pg_ts_config];

charrepl_repl[Natts_pg_ts_config];

HeapTuplenewtup;

memset(repl_val,0,sizeof(repl_val));

memset(repl_null,' ',sizeof(repl_null));

memset(repl_repl,' ',sizeof(repl_repl));

cfgRel=heap_open(TSConfigRelationId,RowExclusiveLock);

foreach(pl,stmt->options)

{

DefElem*defel= (DefElem*)lfirst(pl);

if (pg_strcasecmp(defel->defname,"parser")==0)

{

OidnewPrs;

newPrs=TSParserGetPrsid(defGetQualifiedName(defel), false);

repl_val[Anum_pg_ts_config_cfgparser-1]=ObjectIdGetDatum(newPrs);

repl_repl[Anum_pg_ts_config_cfgparser-1]='r';

}

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

errmsg("text search configuration parameter \"%s\" not recognized",

defel->defname)));

}

newtup=heap_modifytuple(tup,RelationGetDescr(cfgRel),

repl_val,repl_null,repl_repl);

simple_heap_update(cfgRel,&newtup->t_self,newtup);

CatalogUpdateIndexes(cfgRel,newtup);

heap_close(cfgRel,RowExclusiveLock);

returnnewtup;

}

MakeConfigurationMapping(AlterTSConfigurationStmt*stmt,HeapTupletup)

MakeConfigurationMapping(AlterTSConfigurationStmt*stmt,

HeapTupletup,RelationrelMap)

{

OidcfgId=HeapTupleGetOid(tup);

RelationrelMap;

ScanKeyDataskey[2];

SysScanDescscan;

HeapTuplemaptup;

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

ntoken=list_length(stmt->tokentype);

relMap=heap_open(TSConfigMapRelationId,RowExclusiveLock);

if (stmt->override)

{

}

}

}

heap_close(relMap,RowExclusiveLock);

}

DropConfigurationMapping(AlterTSConfigurationStmt*stmt,HeapTupletup)

DropConfigurationMapping(AlterTSConfigurationStmt*stmt,

HeapTupletup,RelationrelMap)

{

OidcfgId=HeapTupleGetOid(tup);

RelationrelMap;

ScanKeyDataskey[2];

SysScanDescscan;

HeapTuplemaptup;

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

ntoken=list_length(stmt->tokentype);

relMap=heap_open(TSConfigMapRelationId,RowExclusiveLock);

i=0;

foreach(c,stmt->tokentype)

{

i++;

}

heap_close(relMap,RowExclusiveLock);

}

;

AlterTSConfigurationStmt:

ALTER TEXT_P SEARCH CONFIGURATION any_name definition

{

AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);

n->cfgname =$5;

n->options =$6;

$$ = (Node *)n;

}

| ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list WITH any_name_list

ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list WITH any_name_list

{

AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);

n->cfgname =$5;

{

NodeTagtype;

List*cfgname;/* qualified name (list of Value strings) */

List*options;/* List of DefElem nodes */