dict_xsyn.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "catalog/pg_collation_d.h"
#include "commands/defrem.h"
#include "tsearch/ts_locale.h"
#include "tsearch/ts_public.h"
#include "utils/formatting.h"

Include dependency graph for dict_xsyn.c:

Go to the source code of this file.

Data Structures
struct	Syn
struct	DictSyn

Functions
	PG_MODULE_MAGIC_EXT (.name="dict_xsyn",.version=PG_VERSION)
	PG_FUNCTION_INFO_V1 (dxsyn_init)
	PG_FUNCTION_INFO_V1 (dxsyn_lexize)
static char *	find_word (char *in, char **end)
static int	compare_syn (const void *a, const void *b)
static void	read_dictionary (DictSyn *d, const char *filename)
Datum	dxsyn_init (PG_FUNCTION_ARGS)
Datum	dxsyn_lexize (PG_FUNCTION_ARGS)

Function Documentation

compare_syn()

static int compare_syn ( const void *  a, const void *  b  )

static

Definition at line 72 of file dict_xsyn.c.

{
    return strcmp(((const Syn *) a)->key, ((const Syn *) b)->key);
}

References a, b, and sort-test::key.

Referenced by dxsyn_lexize(), and read_dictionary().

dxsyn_init()

Datum dxsyn_init

(

PG_FUNCTION_ARGS

)

Definition at line 146 of file dict_xsyn.c.

{
    List       *dictoptions = (List *) PG_GETARG_POINTER(0);
    DictSyn    *d;
    ListCell   *l;
    char       *filename = NULL;
 
    d = (DictSyn *) palloc0(sizeof(DictSyn));
    d->len = 0;
    d->syn = NULL;
    d->matchorig = true;
    d->keeporig = true;
    d->matchsynonyms = false;
    d->keepsynonyms = true;
 
    foreach(l, dictoptions)
    {
        DefElem    *defel = (DefElem *) lfirst(l);
 
        if (strcmp(defel->defname, "matchorig") == 0)
        {
            d->matchorig = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "keeporig") == 0)
        {
            d->keeporig = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "matchsynonyms") == 0)
        {
            d->matchsynonyms = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "keepsynonyms") == 0)
        {
            d->keepsynonyms = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "rules") == 0)
        {
            /* we can't read the rules before parsing all options! */
            filename = defGetString(defel);
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unrecognized xsyn parameter: \"%s\"",
                            defel->defname)));
        }
    }
 
    if (filename)
        read_dictionary(d, filename);
 
    PG_RETURN_POINTER(d);
}

References defGetBoolean(), defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, filename, DictSyn::keeporig, DictSyn::keepsynonyms, DictSyn::len, lfirst, DictSyn::matchorig, DictSyn::matchsynonyms, palloc0(), PG_GETARG_POINTER, PG_RETURN_POINTER, read_dictionary(), and DictSyn::syn.

dxsyn_lexize()

Datum dxsyn_lexize

(

PG_FUNCTION_ARGS

)

Definition at line 202 of file dict_xsyn.c.

{
    DictSyn    *d = (DictSyn *) PG_GETARG_POINTER(0);
    char       *in = (char *) PG_GETARG_POINTER(1);
    int         length = PG_GETARG_INT32(2);
    Syn         word;
    Syn        *found;
    TSLexeme   *res = NULL;
 
    if (!length || d->len == 0)
        PG_RETURN_POINTER(NULL);
 
    /* Create search pattern */
    {
        char       *temp = pnstrdup(in, length);
 
        word.key = str_tolower(temp, length, DEFAULT_COLLATION_OID);
        pfree(temp);
        word.value = NULL;
    }
 
    /* Look for matching syn */
    found = (Syn *) bsearch(&word, d->syn, d->len, sizeof(Syn), compare_syn);
    pfree(word.key);
 
    if (!found)
        PG_RETURN_POINTER(NULL);
 
    /* Parse string of synonyms and return array of words */
    {
        char       *value = found->value;
        char       *syn;
        char       *pos;
        char       *end;
        int         nsyns = 0;
 
        res = palloc(sizeof(TSLexeme));
 
        pos = value;
        while ((syn = find_word(pos, &end)) != NULL)
        {
            res = repalloc(res, sizeof(TSLexeme) * (nsyns + 2));
 
            /* The first word is output only if keeporig=true */
            if (pos != value || d->keeporig)
            {
                res[nsyns].lexeme = pnstrdup(syn, end - syn);
                res[nsyns].nvariant = 0;
                res[nsyns].flags = 0;
                nsyns++;
            }
 
            pos = end;
 
            /* Stop if we are not to output the synonyms */
            if (!d->keepsynonyms)
                break;
        }
        res[nsyns].lexeme = NULL;
    }
 
    PG_RETURN_POINTER(res);
}

References compare_syn(), find_word(), TSLexeme::flags, DictSyn::keeporig, DictSyn::keepsynonyms, DictSyn::len, TSLexeme::lexeme, TSLexeme::nvariant, palloc(), pfree(), PG_GETARG_INT32, PG_GETARG_POINTER, PG_RETURN_POINTER, pnstrdup(), repalloc(), str_tolower(), DictSyn::syn, Syn::value, value, and word().

find_word()

static char * find_word ( char *  in, char **  end  )

static

Definition at line 51 of file dict_xsyn.c.

{
    char       *start;
 
    *end = NULL;
    while (*in && isspace((unsigned char) *in))
        in += pg_mblen(in);
 
    if (!*in || *in == '#')
        return NULL;
    start = in;
 
    while (*in && !isspace((unsigned char) *in))
        in += pg_mblen(in);
 
    *end = in;
 
    return start;
}

References pg_mblen(), and start.

Referenced by dxsyn_lexize(), and read_dictionary().

PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1

(

dxsyn_init

)

PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1

(

dxsyn_lexize

)

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "dict_xsyn",
		.	version = PG_VERSION
	)

read_dictionary()

static void read_dictionary ( DictSyn *  d, const char *  filename  )

static

Definition at line 78 of file dict_xsyn.c.

{
    char       *real_filename = get_tsearch_config_filename(filename, "rules");
    tsearch_readline_state trst;
    char       *line;
    int         cur = 0;
 
    if (!tsearch_readline_begin(&trst, real_filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open synonym file \"%s\": %m",
                        real_filename)));
 
    while ((line = tsearch_readline(&trst)) != NULL)
    {
        char       *value;
        char       *key;
        char       *pos;
        char       *end;
 
        if (*line == '\0')
            continue;
 
        value = str_tolower(line, strlen(line), DEFAULT_COLLATION_OID);
        pfree(line);
 
        pos = value;
        while ((key = find_word(pos, &end)) != NULL)
        {
            /* Enlarge syn structure if full */
            if (cur == d->len)
            {
                d->len = (d->len > 0) ? 2 * d->len : 16;
                if (d->syn)
                    d->syn = (Syn *) repalloc(d->syn, sizeof(Syn) * d->len);
                else
                    d->syn = (Syn *) palloc(sizeof(Syn) * d->len);
            }
 
            /* Save first word only if we will match it */
            if (pos != value || d->matchorig)
            {
                d->syn[cur].key = pnstrdup(key, end - key);
                d->syn[cur].value = pstrdup(value);
 
                cur++;
            }
 
            pos = end;
 
            /* Don't bother scanning synonyms if we will not match them */
            if (!d->matchsynonyms)
                break;
        }
 
        pfree(value);
    }
 
    tsearch_readline_end(&trst);
 
    d->len = cur;
    if (cur > 1)
        qsort(d->syn, d->len, sizeof(Syn), compare_syn);
 
    pfree(real_filename);
}

References compare_syn(), cur, ereport, errcode(), errmsg(), ERROR, filename, find_word(), get_tsearch_config_filename(), if(), Syn::key, sort-test::key, DictSyn::len, DictSyn::matchorig, DictSyn::matchsynonyms, palloc(), pfree(), pnstrdup(), pstrdup(), qsort, repalloc(), str_tolower(), DictSyn::syn, tsearch_readline(), tsearch_readline_begin(), tsearch_readline_end(), Syn::value, and value.

Referenced by dxsyn_init().