510 lines
13 KiB
C
510 lines
13 KiB
C
/*
|
|
* interface functions to tscfg
|
|
* Teodor Sigaev <teodor@sigaev.ru>
|
|
*/
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <locale.h>
|
|
|
|
#include "postgres.h"
|
|
#include "fmgr.h"
|
|
#include "utils/array.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "executor/spi.h"
|
|
|
|
#include "ts_cfg.h"
|
|
#include "dict.h"
|
|
#include "wparser.h"
|
|
#include "snmap.h"
|
|
#include "common.h"
|
|
#include "tsvector.h"
|
|
|
|
/*********top interface**********/
|
|
|
|
static void *plan_getcfg_bylocale=NULL;
|
|
static void *plan_getcfg=NULL;
|
|
static void *plan_getmap=NULL;
|
|
static void *plan_name2id=NULL;
|
|
static Oid current_cfg_id=0;
|
|
|
|
void
|
|
init_cfg(Oid id, TSCfgInfo *cfg) {
|
|
Oid arg[2]={ OIDOID, OIDOID };
|
|
bool isnull;
|
|
Datum pars[2]={ ObjectIdGetDatum(id), ObjectIdGetDatum(id) } ;
|
|
int stat,i,j;
|
|
text *ptr;
|
|
text *prsname=NULL;
|
|
MemoryContext oldcontext;
|
|
|
|
memset(cfg,0,sizeof(TSCfgInfo));
|
|
SPI_connect();
|
|
if ( !plan_getcfg ) {
|
|
plan_getcfg = SPI_saveplan( SPI_prepare( "select prs_name from pg_ts_cfg where oid = $1" , 1, arg ) );
|
|
if ( !plan_getcfg )
|
|
ts_error(ERROR, "SPI_prepare() failed");
|
|
}
|
|
|
|
stat = SPI_execp(plan_getcfg, pars, " ", 1);
|
|
if ( stat < 0 )
|
|
ts_error (ERROR, "SPI_execp return %d", stat);
|
|
if ( SPI_processed > 0 ) {
|
|
prsname = (text*) DatumGetPointer(
|
|
SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull)
|
|
);
|
|
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
|
|
prsname = ptextdup( prsname );
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
cfg->id=id;
|
|
} else
|
|
ts_error(ERROR, "No tsearch cfg with id %d", id);
|
|
|
|
arg[0]=TEXTOID;
|
|
if ( !plan_getmap ) {
|
|
plan_getmap = SPI_saveplan( SPI_prepare( "select lt.tokid, pg_ts_cfgmap.dict_name from pg_ts_cfgmap, pg_ts_cfg, token_type( $1 ) as lt where lt.alias = pg_ts_cfgmap.tok_alias and pg_ts_cfgmap.ts_name = pg_ts_cfg.ts_name and pg_ts_cfg.oid= $2 order by lt.tokid desc;" , 2, arg ) );
|
|
if ( !plan_getmap )
|
|
ts_error(ERROR, "SPI_prepare() failed");
|
|
}
|
|
|
|
pars[0]=PointerGetDatum( prsname );
|
|
stat = SPI_execp(plan_getmap, pars, " ", 0);
|
|
if ( stat < 0 )
|
|
ts_error (ERROR, "SPI_execp return %d", stat);
|
|
if ( SPI_processed <= 0 )
|
|
ts_error(ERROR, "No parser with id %d", id);
|
|
|
|
for(i=0;i<SPI_processed;i++) {
|
|
int lexid = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull));
|
|
ArrayType *toasted_a = (ArrayType*)PointerGetDatum(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull));
|
|
ArrayType *a;
|
|
|
|
if ( !cfg->map ) {
|
|
cfg->len=lexid+1;
|
|
cfg->map = (ListDictionary*)malloc( sizeof(ListDictionary)*cfg->len );
|
|
if ( !cfg->map )
|
|
ts_error(ERROR,"No memory");
|
|
memset( cfg->map, 0, sizeof(ListDictionary)*cfg->len );
|
|
}
|
|
|
|
if (isnull)
|
|
continue;
|
|
|
|
a=(ArrayType*)PointerGetDatum( PG_DETOAST_DATUM( DatumGetPointer(toasted_a) ) );
|
|
|
|
if ( ARR_NDIM(a) != 1 )
|
|
ts_error(ERROR,"Wrong dimension");
|
|
if ( ARRNELEMS(a) < 1 )
|
|
continue;
|
|
|
|
cfg->map[lexid].len=ARRNELEMS(a);
|
|
cfg->map[lexid].dict_id=(Datum*)malloc( sizeof(Datum)*cfg->map[lexid].len );
|
|
memset(cfg->map[lexid].dict_id,0,sizeof(Datum)*cfg->map[lexid].len );
|
|
ptr=(text*)ARR_DATA_PTR(a);
|
|
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
|
|
for(j=0;j<cfg->map[lexid].len;j++) {
|
|
cfg->map[lexid].dict_id[j] = PointerGetDatum(ptextdup(ptr));
|
|
ptr=NEXTVAL(ptr);
|
|
}
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
if ( a != toasted_a )
|
|
pfree(a);
|
|
}
|
|
|
|
SPI_finish();
|
|
cfg->prs_id = name2id_prs( prsname );
|
|
pfree(prsname);
|
|
for(i=0;i<cfg->len;i++) {
|
|
for(j=0;j<cfg->map[i].len;j++) {
|
|
ptr = (text*)DatumGetPointer( cfg->map[i].dict_id[j] );
|
|
cfg->map[i].dict_id[j] = ObjectIdGetDatum( name2id_dict(ptr) );
|
|
pfree(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
TSCfgInfo *last_cfg;
|
|
int len;
|
|
int reallen;
|
|
TSCfgInfo *list;
|
|
SNMap name2id_map;
|
|
} CFGList;
|
|
|
|
static CFGList CList = {NULL,0,0,NULL,{0,0,NULL}};
|
|
|
|
void
|
|
reset_cfg(void) {
|
|
freeSNMap( &(CList.name2id_map) );
|
|
if ( CList.list ) {
|
|
int i,j;
|
|
for(i=0;i<CList.len;i++)
|
|
if ( CList.list[i].map ) {
|
|
for(j=0;j<CList.list[i].len;j++)
|
|
if ( CList.list[i].map[j].dict_id )
|
|
free(CList.list[i].map[j].dict_id);
|
|
free( CList.list[i].map );
|
|
}
|
|
free(CList.list);
|
|
}
|
|
memset(&CList,0,sizeof(CFGList));
|
|
}
|
|
|
|
static int
|
|
comparecfg(const void *a, const void *b) {
|
|
return ((TSCfgInfo*)a)->id - ((TSCfgInfo*)b)->id;
|
|
}
|
|
|
|
TSCfgInfo *
|
|
findcfg(Oid id) {
|
|
/* last used cfg */
|
|
if ( CList.last_cfg && CList.last_cfg->id==id )
|
|
return CList.last_cfg;
|
|
|
|
/* already used cfg */
|
|
if ( CList.len != 0 ) {
|
|
TSCfgInfo key;
|
|
key.id=id;
|
|
CList.last_cfg = bsearch(&key, CList.list, CList.len, sizeof(TSCfgInfo), comparecfg);
|
|
if ( CList.last_cfg != NULL )
|
|
return CList.last_cfg;
|
|
}
|
|
|
|
/* last chance */
|
|
if ( CList.len==CList.reallen ) {
|
|
TSCfgInfo *tmp;
|
|
int reallen = ( CList.reallen ) ? 2*CList.reallen : 16;
|
|
tmp=(TSCfgInfo*)realloc(CList.list,sizeof(TSCfgInfo)*reallen);
|
|
if ( !tmp )
|
|
ts_error(ERROR,"No memory");
|
|
CList.reallen=reallen;
|
|
CList.list=tmp;
|
|
}
|
|
CList.last_cfg=&(CList.list[CList.len]);
|
|
init_cfg(id, CList.last_cfg);
|
|
CList.len++;
|
|
qsort(CList.list, CList.len, sizeof(TSCfgInfo), comparecfg);
|
|
return findcfg(id); /* qsort changed order!! */;
|
|
}
|
|
|
|
|
|
Oid
|
|
name2id_cfg(text *name) {
|
|
Oid arg[1]={ TEXTOID };
|
|
bool isnull;
|
|
Datum pars[1]={ PointerGetDatum(name) };
|
|
int stat;
|
|
Oid id=findSNMap_t( &(CList.name2id_map), name );
|
|
|
|
if ( id )
|
|
return id;
|
|
|
|
SPI_connect();
|
|
if ( !plan_name2id ) {
|
|
plan_name2id = SPI_saveplan( SPI_prepare( "select oid from pg_ts_cfg where ts_name = $1" , 1, arg ) );
|
|
if ( !plan_name2id )
|
|
elog(ERROR, "SPI_prepare() failed");
|
|
}
|
|
|
|
stat = SPI_execp(plan_name2id, pars, " ", 1);
|
|
if ( stat < 0 )
|
|
elog (ERROR, "SPI_execp return %d", stat);
|
|
if ( SPI_processed > 0 ) {
|
|
id=DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull) );
|
|
if ( isnull )
|
|
elog(ERROR, "Null id for tsearch config");
|
|
} else
|
|
elog(ERROR, "No tsearch config");
|
|
SPI_finish();
|
|
addSNMap_t( &(CList.name2id_map), name, id );
|
|
return id;
|
|
}
|
|
|
|
|
|
void
|
|
parsetext_v2(TSCfgInfo *cfg, PRSTEXT * prs, char *buf, int4 buflen) {
|
|
int type, lenlemm, i;
|
|
char *lemm=NULL;
|
|
WParserInfo *prsobj = findprs(cfg->prs_id);
|
|
|
|
prsobj->prs=(void*)DatumGetPointer(
|
|
FunctionCall2(
|
|
&(prsobj->start_info),
|
|
PointerGetDatum(buf),
|
|
Int32GetDatum(buflen)
|
|
)
|
|
);
|
|
|
|
while( ( type=DatumGetInt32(FunctionCall3(
|
|
&(prsobj->getlexeme_info),
|
|
PointerGetDatum(prsobj->prs),
|
|
PointerGetDatum(&lemm),
|
|
PointerGetDatum(&lenlemm))) ) != 0 ) {
|
|
|
|
if ( lenlemm >= MAXSTRLEN )
|
|
elog(ERROR, "Word is too long");
|
|
|
|
|
|
if ( type >= cfg->len ) /* skip this type of lexem */
|
|
continue;
|
|
|
|
for(i=0;i<cfg->map[type].len;i++) {
|
|
DictInfo *dict=finddict( DatumGetObjectId(cfg->map[type].dict_id[i]) );
|
|
char **norms, **ptr;
|
|
|
|
norms = ptr = (char**)DatumGetPointer(
|
|
FunctionCall3(
|
|
&(dict->lexize_info),
|
|
PointerGetDatum(dict->dictionary),
|
|
PointerGetDatum(lemm),
|
|
PointerGetDatum(lenlemm)
|
|
)
|
|
);
|
|
if ( !norms ) /* dictionary doesn't know this lexem */
|
|
continue;
|
|
|
|
prs->pos++; /*set pos*/
|
|
|
|
while( *ptr ) {
|
|
if (prs->curwords == prs->lenwords) {
|
|
prs->lenwords *= 2;
|
|
prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD));
|
|
}
|
|
|
|
prs->words[prs->curwords].len = strlen(*ptr);
|
|
prs->words[prs->curwords].word = *ptr;
|
|
prs->words[prs->curwords].alen = 0;
|
|
prs->words[prs->curwords].pos.pos = LIMITPOS(prs->pos);
|
|
ptr++;
|
|
prs->curwords++;
|
|
}
|
|
pfree(norms);
|
|
break; /* lexem already normalized or is stop word*/
|
|
}
|
|
}
|
|
|
|
FunctionCall1(
|
|
&(prsobj->end_info),
|
|
PointerGetDatum(prsobj->prs)
|
|
);
|
|
}
|
|
|
|
static void
|
|
hladdword(HLPRSTEXT * prs, char *buf, int4 buflen, int type) {
|
|
while (prs->curwords >= prs->lenwords) {
|
|
prs->lenwords *= 2;
|
|
prs->words = (HLWORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(HLWORD));
|
|
}
|
|
memset( &(prs->words[prs->curwords]), 0, sizeof(HLWORD) );
|
|
prs->words[prs->curwords].type = (uint8)type;
|
|
prs->words[prs->curwords].len = buflen;
|
|
prs->words[prs->curwords].word = palloc(buflen);
|
|
memcpy(prs->words[prs->curwords].word, buf, buflen);
|
|
prs->curwords++;
|
|
}
|
|
|
|
static void
|
|
hlfinditem(HLPRSTEXT * prs, QUERYTYPE *query, char *buf, int buflen ) {
|
|
int i;
|
|
ITEM *item=GETQUERY(query);
|
|
HLWORD *word=&( prs->words[prs->curwords-1] );
|
|
|
|
while (prs->curwords + query->size >= prs->lenwords) {
|
|
prs->lenwords *= 2;
|
|
prs->words = (HLWORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(HLWORD));
|
|
}
|
|
|
|
for(i=0; i<query->size; i++) {
|
|
if ( item->type == VAL && item->length == buflen && strncmp( GETOPERAND(query) + item->distance, buf, buflen )==0 ) {
|
|
if ( word->item ) {
|
|
memcpy( &(prs->words[prs->curwords]), word, sizeof(HLWORD) );
|
|
prs->words[prs->curwords].item=item;
|
|
prs->words[prs->curwords].repeated=1;
|
|
prs->curwords++;
|
|
} else
|
|
word->item=item;
|
|
}
|
|
item++;
|
|
}
|
|
}
|
|
|
|
void
|
|
hlparsetext(TSCfgInfo *cfg, HLPRSTEXT * prs, QUERYTYPE *query, char *buf, int4 buflen) {
|
|
int type, lenlemm, i;
|
|
char *lemm=NULL;
|
|
WParserInfo *prsobj = findprs(cfg->prs_id);
|
|
|
|
prsobj->prs=(void*)DatumGetPointer(
|
|
FunctionCall2(
|
|
&(prsobj->start_info),
|
|
PointerGetDatum(buf),
|
|
Int32GetDatum(buflen)
|
|
)
|
|
);
|
|
|
|
while( ( type=DatumGetInt32(FunctionCall3(
|
|
&(prsobj->getlexeme_info),
|
|
PointerGetDatum(prsobj->prs),
|
|
PointerGetDatum(&lemm),
|
|
PointerGetDatum(&lenlemm))) ) != 0 ) {
|
|
|
|
if ( lenlemm >= MAXSTRLEN )
|
|
elog(ERROR, "Word is too long");
|
|
|
|
hladdword(prs,lemm,lenlemm,type);
|
|
|
|
if ( type >= cfg->len )
|
|
continue;
|
|
|
|
for(i=0;i<cfg->map[type].len;i++) {
|
|
DictInfo *dict=finddict( DatumGetObjectId(cfg->map[type].dict_id[i]) );
|
|
char **norms, **ptr;
|
|
|
|
norms = ptr = (char**)DatumGetPointer(
|
|
FunctionCall3(
|
|
&(dict->lexize_info),
|
|
PointerGetDatum(dict->dictionary),
|
|
PointerGetDatum(lemm),
|
|
PointerGetDatum(lenlemm)
|
|
)
|
|
);
|
|
if ( !norms ) /* dictionary doesn't know this lexem */
|
|
continue;
|
|
|
|
while( *ptr ) {
|
|
hlfinditem(prs,query,*ptr,strlen(*ptr));
|
|
pfree(*ptr);
|
|
ptr++;
|
|
}
|
|
pfree(norms);
|
|
break; /* lexem already normalized or is stop word*/
|
|
}
|
|
}
|
|
|
|
FunctionCall1(
|
|
&(prsobj->end_info),
|
|
PointerGetDatum(prsobj->prs)
|
|
);
|
|
}
|
|
|
|
text*
|
|
genhl(HLPRSTEXT * prs) {
|
|
text *out;
|
|
int len=128;
|
|
char *ptr;
|
|
HLWORD *wrd=prs->words;
|
|
|
|
out = (text*)palloc( len );
|
|
ptr=((char*)out) + VARHDRSZ;
|
|
|
|
while( wrd - prs->words < prs->curwords ) {
|
|
while ( wrd->len + prs->stopsellen + prs->startsellen + (ptr - ((char*)out)) >= len ) {
|
|
int dist = ptr - ((char*)out);
|
|
len*= 2;
|
|
out = (text *) repalloc(out, len);
|
|
ptr=((char*)out) + dist;
|
|
}
|
|
|
|
if ( wrd->in && !wrd->skip && !wrd->repeated ) {
|
|
if ( wrd->replace ) {
|
|
*ptr=' ';
|
|
ptr++;
|
|
} else {
|
|
if (wrd->selected) {
|
|
memcpy(ptr,prs->startsel,prs->startsellen);
|
|
ptr+=prs->startsellen;
|
|
}
|
|
memcpy(ptr,wrd->word,wrd->len);
|
|
ptr+=wrd->len;
|
|
if (wrd->selected) {
|
|
memcpy(ptr,prs->stopsel,prs->stopsellen);
|
|
ptr+=prs->stopsellen;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !wrd->repeated )
|
|
pfree(wrd->word);
|
|
|
|
wrd++;
|
|
}
|
|
|
|
VARATT_SIZEP(out)=ptr - ((char*)out);
|
|
return out;
|
|
}
|
|
|
|
int
|
|
get_currcfg(void) {
|
|
Oid arg[1]={ TEXTOID };
|
|
const char *curlocale;
|
|
Datum pars[1];
|
|
bool isnull;
|
|
int stat;
|
|
|
|
if ( current_cfg_id > 0 )
|
|
return current_cfg_id;
|
|
|
|
SPI_connect();
|
|
if ( !plan_getcfg_bylocale ) {
|
|
plan_getcfg_bylocale=SPI_saveplan( SPI_prepare( "select oid from pg_ts_cfg where locale = $1 ", 1, arg ) );
|
|
if ( !plan_getcfg_bylocale )
|
|
elog(ERROR, "SPI_prepare() failed");
|
|
}
|
|
|
|
curlocale = setlocale(LC_CTYPE, NULL);
|
|
pars[0] = PointerGetDatum( char2text((char*)curlocale) );
|
|
stat = SPI_execp(plan_getcfg_bylocale, pars, " ", 1);
|
|
|
|
if ( stat < 0 )
|
|
elog (ERROR, "SPI_execp return %d", stat);
|
|
if ( SPI_processed > 0 )
|
|
current_cfg_id = DatumGetObjectId( SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull) );
|
|
else
|
|
elog(ERROR,"Can't find tsearch config by locale");
|
|
|
|
pfree(DatumGetPointer(pars[0]));
|
|
SPI_finish();
|
|
return current_cfg_id;
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(set_curcfg);
|
|
Datum set_curcfg(PG_FUNCTION_ARGS);
|
|
Datum
|
|
set_curcfg(PG_FUNCTION_ARGS) {
|
|
findcfg(PG_GETARG_OID(0));
|
|
current_cfg_id=PG_GETARG_OID(0);
|
|
PG_RETURN_VOID();
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(set_curcfg_byname);
|
|
Datum set_curcfg_byname(PG_FUNCTION_ARGS);
|
|
Datum
|
|
set_curcfg_byname(PG_FUNCTION_ARGS) {
|
|
text *name=PG_GETARG_TEXT_P(0);
|
|
|
|
DirectFunctionCall1(
|
|
set_curcfg,
|
|
ObjectIdGetDatum( name2id_cfg(name) )
|
|
);
|
|
PG_FREE_IF_COPY(name, 0);
|
|
PG_RETURN_VOID();
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(show_curcfg);
|
|
Datum show_curcfg(PG_FUNCTION_ARGS);
|
|
Datum
|
|
show_curcfg(PG_FUNCTION_ARGS) {
|
|
PG_RETURN_OID( get_currcfg() );
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(reset_tsearch);
|
|
Datum reset_tsearch(PG_FUNCTION_ARGS);
|
|
Datum
|
|
reset_tsearch(PG_FUNCTION_ARGS) {
|
|
ts_error(NOTICE,"TSearch cache cleaned");
|
|
PG_RETURN_VOID();
|
|
}
|