dict_synonym.c File Reference

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

Include dependency graph for dict_synonym.c:

Go to the source code of this file.

Data Structures
struct	Syn
struct	DictSyn

Functions
static char *	findwrd (char *in, char **end, uint16 *flags)
static int	compareSyn (const void *a, const void *b)
Datum	dsynonym_init (PG_FUNCTION_ARGS)
Datum	dsynonym_lexize (PG_FUNCTION_ARGS)

Function Documentation

compareSyn()

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

static

Definition at line 87 of file dict_synonym.c.

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

References a, and b.

Referenced by dsynonym_init(), and dsynonym_lexize().

dsynonym_init()

Datum dsynonym_init

(

PG_FUNCTION_ARGS

)

Definition at line 94 of file dict_synonym.c.

{
    List       *dictoptions = (List *) PG_GETARG_POINTER(0);
    DictSyn    *d;
    ListCell   *l;
    char       *filename = NULL;
    bool        case_sensitive = false;
    tsearch_readline_state trst;
    char       *starti,
               *starto,
               *end = NULL;
    int         cur = 0;
    char       *line = NULL;
    uint16      flags = 0;
 
    foreach(l, dictoptions)
    {
        DefElem    *defel = (DefElem *) lfirst(l);
 
        if (strcmp(defel->defname, "synonyms") == 0)
            filename = defGetString(defel);
        else if (strcmp(defel->defname, "casesensitive") == 0)
            case_sensitive = defGetBoolean(defel);
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unrecognized synonym parameter: \"%s\"",
                            defel->defname)));
    }
 
    if (!filename)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("missing Synonyms parameter")));
 
    filename = get_tsearch_config_filename(filename, "syn");
 
    if (!tsearch_readline_begin(&trst, filename))
        ereport(ERROR,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not open synonym file \"%s\": %m",
                        filename)));
 
    d = (DictSyn *) palloc0(sizeof(DictSyn));
 
    while ((line = tsearch_readline(&trst)) != NULL)
    {
        starti = findwrd(line, &end, NULL);
        if (!starti)
        {
            /* Empty line */
            goto skipline;
        }
        if (*end == '\0')
        {
            /* A line with only one word. Ignore silently. */
            goto skipline;
        }
        *end = '\0';
 
        starto = findwrd(end + 1, &end, &flags);
        if (!starto)
        {
            /* A line with only one word (+whitespace). Ignore silently. */
            goto skipline;
        }
        *end = '\0';
 
        /*
         * starti now points to the first word, and starto to the second word
         * on the line, with a \0 terminator at the end of both words.
         */
 
        if (cur >= d->len)
        {
            if (d->len == 0)
            {
                d->len = 64;
                d->syn = (Syn *) palloc(sizeof(Syn) * d->len);
            }
            else
            {
                d->len *= 2;
                d->syn = (Syn *) repalloc(d->syn, sizeof(Syn) * d->len);
            }
        }
 
        if (case_sensitive)
        {
            d->syn[cur].in = pstrdup(starti);
            d->syn[cur].out = pstrdup(starto);
        }
        else
        {
            d->syn[cur].in = str_tolower(starti, strlen(starti), DEFAULT_COLLATION_OID);
            d->syn[cur].out = str_tolower(starto, strlen(starto), DEFAULT_COLLATION_OID);
        }
 
        d->syn[cur].outlen = strlen(starto);
        d->syn[cur].flags = flags;
 
        cur++;
 
skipline:
        pfree(line);
    }
 
    tsearch_readline_end(&trst);
 
    d->len = cur;
    qsort(d->syn, d->len, sizeof(Syn), compareSyn);
 
    d->case_sensitive = case_sensitive;
 
    PG_RETURN_POINTER(d);
}

References DictSyn::case_sensitive, compareSyn(), cur, defGetBoolean(), defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, filename, findwrd(), Syn::flags, get_tsearch_config_filename(), Syn::in, DictSyn::len, lfirst, Syn::out, Syn::outlen, palloc(), palloc0(), pfree(), PG_GETARG_POINTER, PG_RETURN_POINTER, pstrdup(), qsort, repalloc(), str_tolower(), DictSyn::syn, tsearch_readline(), tsearch_readline_begin(), and tsearch_readline_end().

dsynonym_lexize()

Datum dsynonym_lexize

(

PG_FUNCTION_ARGS

)

Definition at line 212 of file dict_synonym.c.

{
    DictSyn    *d = (DictSyn *) PG_GETARG_POINTER(0);
    char       *in = (char *) PG_GETARG_POINTER(1);
    int32       len = PG_GETARG_INT32(2);
    Syn         key,
               *found;
    TSLexeme   *res;
 
    /* note: d->len test protects against Solaris bsearch-of-no-items bug */
    if (len <= 0 || d->len <= 0)
        PG_RETURN_POINTER(NULL);
 
    if (d->case_sensitive)
        key.in = pnstrdup(in, len);
    else
        key.in = str_tolower(in, len, DEFAULT_COLLATION_OID);
 
    key.out = NULL;
 
    found = (Syn *) bsearch(&key, d->syn, d->len, sizeof(Syn), compareSyn);
    pfree(key.in);
 
    if (!found)
        PG_RETURN_POINTER(NULL);
 
    res = palloc0(sizeof(TSLexeme) * 2);
    res[0].lexeme = pnstrdup(found->out, found->outlen);
    res[0].flags = found->flags;
 
    PG_RETURN_POINTER(res);
}

References DictSyn::case_sensitive, compareSyn(), Syn::flags, sort-test::key, DictSyn::len, len, Syn::out, Syn::outlen, palloc0(), pfree(), PG_GETARG_INT32, PG_GETARG_POINTER, PG_RETURN_POINTER, pnstrdup(), res, str_tolower(), and DictSyn::syn.

findwrd()

static char * findwrd ( char *  in, char **  end, uint16 *  flags  )

static

Definition at line 46 of file dict_synonym.c.

{
    char       *start;
    char       *lastchar;
 
    /* Skip leading spaces */
    while (*in && isspace((unsigned char) *in))
        in += pg_mblen(in);
 
    /* Return NULL on empty lines */
    if (*in == '\0')
    {
        *end = NULL;
        return NULL;
    }
 
    lastchar = start = in;
 
    /* Find end of word */
    while (*in && !isspace((unsigned char) *in))
    {
        lastchar = in;
        in += pg_mblen(in);
    }
 
    if (in - lastchar == 1 && t_iseq(lastchar, '*') && flags)
    {
        *flags = TSL_PREFIX;
        *end = lastchar;
    }
    else
    {
        if (flags)
            *flags = 0;
        *end = in;
    }
 
    return start;
}

References pg_mblen(), start, t_iseq, and TSL_PREFIX.

Referenced by dsynonym_init().