trgm_op.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "catalog/pg_collation_d.h"
#include "catalog/pg_type.h"
#include "common/int.h"
#include "lib/qunique.h"
#include "miscadmin.h"
#include "trgm.h"
#include "tsearch/ts_locale.h"
#include "utils/formatting.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_crc.h"

Include dependency graph for trgm_op.c:

Go to the source code of this file.

Data Structures
struct	pos_trgm
struct	growable_trgm_array

Macros
#define	TRGM_BOUND_LEFT   0x01 /* trigram is left bound of word */
#define	TRGM_BOUND_RIGHT   0x02 /* trigram is right bound of word */
#define	WORD_SIMILARITY_CHECK_ONLY
#define	WORD_SIMILARITY_STRICT
#define	CMPCHAR(a, b)   ( ((a)==(b)) ? 0 : ( ((a)<(b)) ? -1 : 1 ) )
#define	CMPPCHAR_S(a, b, i)   CMPCHAR( *(((const signed char*)(a))+i), *(((const signed char*)(b))+i) )
#define	CMPPCHAR_UNS(a, b, i)   CMPCHAR( *(((const unsigned char*)(a))+i), *(((const unsigned char*)(b))+i) )

Typedefs
typedef uint8	TrgmBound

Functions
	PG_MODULE_MAGIC_EXT (.name="pg_trgm",.version=PG_VERSION)
	PG_FUNCTION_INFO_V1 (set_limit)
	PG_FUNCTION_INFO_V1 (show_limit)
	PG_FUNCTION_INFO_V1 (show_trgm)
	PG_FUNCTION_INFO_V1 (similarity)
	PG_FUNCTION_INFO_V1 (word_similarity)
	PG_FUNCTION_INFO_V1 (strict_word_similarity)
	PG_FUNCTION_INFO_V1 (similarity_dist)
	PG_FUNCTION_INFO_V1 (similarity_op)
	PG_FUNCTION_INFO_V1 (word_similarity_op)
	PG_FUNCTION_INFO_V1 (word_similarity_commutator_op)
	PG_FUNCTION_INFO_V1 (word_similarity_dist_op)
	PG_FUNCTION_INFO_V1 (word_similarity_dist_commutator_op)
	PG_FUNCTION_INFO_V1 (strict_word_similarity_op)
	PG_FUNCTION_INFO_V1 (strict_word_similarity_commutator_op)
	PG_FUNCTION_INFO_V1 (strict_word_similarity_dist_op)
	PG_FUNCTION_INFO_V1 (strict_word_similarity_dist_commutator_op)
static int	CMPTRGM_CHOOSE (const void *a, const void *b)
static void	init_trgm_array (growable_trgm_array *arr, int slen)
static void	enlarge_trgm_array (growable_trgm_array *arr, int needed)
void	_PG_init (void)
static int	CMPTRGM_SIGNED (const void *a, const void *b)
static int	CMPTRGM_UNSIGNED (const void *a, const void *b)
Datum	set_limit (PG_FUNCTION_ARGS)
double	index_strategy_get_limit (StrategyNumber strategy)
Datum	show_limit (PG_FUNCTION_ARGS)
static int	comp_trgm (const void *a, const void *b)
static char *	find_word (char *str, int lenstr, char **endword)
void	compact_trigram (trgm *tptr, char *str, int bytelen)
static void	make_trigrams (growable_trgm_array *dst, char *str, int bytelen)
static void	generate_trgm_only (growable_trgm_array *dst, char *str, int slen, TrgmBound **bounds_p)
TRGM *	generate_trgm (char *str, int slen)
static pos_trgm *	make_positional_trgm (trgm *trg1, int len1, trgm *trg2, int len2)
static int	comp_ptrgm (const void *v1, const void *v2)
static float4	iterate_word_similarity (int *trg2indexes, bool *found, int ulen1, int len2, int len, uint8 flags, TrgmBound *bounds)
static float4	calc_word_similarity (char *str1, int slen1, char *str2, int slen2, uint8 flags)
static const char *	get_wildcard_part (const char *str, int lenstr, char *buf, int *bytelen)
TRGM *	generate_wildcard_trgm (const char *str, int slen)
uint32	trgm2int (trgm *ptr)
Datum	show_trgm (PG_FUNCTION_ARGS)
float4	cnt_sml (TRGM *trg1, TRGM *trg2, bool inexact)
bool	trgm_contained_by (TRGM *trg1, TRGM *trg2)
bool *	trgm_presence_map (TRGM *query, TRGM *key)
Datum	similarity (PG_FUNCTION_ARGS)
Datum	word_similarity (PG_FUNCTION_ARGS)
Datum	strict_word_similarity (PG_FUNCTION_ARGS)
Datum	similarity_dist (PG_FUNCTION_ARGS)
Datum	similarity_op (PG_FUNCTION_ARGS)
Datum	word_similarity_op (PG_FUNCTION_ARGS)
Datum	word_similarity_commutator_op (PG_FUNCTION_ARGS)
Datum	word_similarity_dist_op (PG_FUNCTION_ARGS)
Datum	word_similarity_dist_commutator_op (PG_FUNCTION_ARGS)
Datum	strict_word_similarity_op (PG_FUNCTION_ARGS)
Datum	strict_word_similarity_commutator_op (PG_FUNCTION_ARGS)
Datum	strict_word_similarity_dist_op (PG_FUNCTION_ARGS)
Datum	strict_word_similarity_dist_commutator_op (PG_FUNCTION_ARGS)

Variables
double	similarity_threshold = 0.3f
double	word_similarity_threshold = 0.6f
double	strict_word_similarity_threshold = 0.5f
int(*	CMPTRGM )(const void *a, const void *b) = CMPTRGM_CHOOSE

Macro Definition Documentation

CMPCHAR

#define CMPCHAR	(		a,
			b
	)		( ((a)==(b)) ? 0 : ( ((a)<(b)) ? -1 : 1 ) )

Definition at line 186 of file trgm_op.c.

CMPPCHAR_S

#define CMPPCHAR_S	(		a,
			b,
			i
	)		CMPCHAR( *(((const signed char*)(a))+i), *(((const signed char*)(b))+i) )

CMPPCHAR_UNS

#define CMPPCHAR_UNS	(		a,
			b,
			i
	)		CMPCHAR( *(((const unsigned char*)(a))+i), *(((const unsigned char*)(b))+i) )

TRGM_BOUND_LEFT

#define TRGM_BOUND_LEFT   0x01 /* trigram is left bound of word */

Definition at line 60 of file trgm_op.c.

TRGM_BOUND_RIGHT

#define TRGM_BOUND_RIGHT   0x02 /* trigram is right bound of word */

Definition at line 61 of file trgm_op.c.

WORD_SIMILARITY_CHECK_ONLY

#define WORD_SIMILARITY_CHECK_ONLY

Value:

                                             0x01   /* only check existence of similar
                                             * search pattern in text */

Definition at line 64 of file trgm_op.c.

WORD_SIMILARITY_STRICT

#define WORD_SIMILARITY_STRICT

Value:

                                             0x02   /* force bounds of extent to match
                                             * word bounds */

Definition at line 65 of file trgm_op.c.

Typedef Documentation

TrgmBound

typedef uint8 TrgmBound

Definition at line 59 of file trgm_op.c.

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 143 of file trgm_op.c.

{
    /* Define custom GUC variables. */
    DefineCustomRealVariable("pg_trgm.similarity_threshold",
                             "Sets the threshold used by the % operator.",
                             "Valid range is 0.0 .. 1.0.",
                             &similarity_threshold,
                             0.3f,
                             0.0,
                             1.0,
                             PGC_USERSET,
                             0,
                             NULL,
                             NULL,
                             NULL);
    DefineCustomRealVariable("pg_trgm.word_similarity_threshold",
                             "Sets the threshold used by the <% operator.",
                             "Valid range is 0.0 .. 1.0.",
                             &word_similarity_threshold,
                             0.6f,
                             0.0,
                             1.0,
                             PGC_USERSET,
                             0,
                             NULL,
                             NULL,
                             NULL);
    DefineCustomRealVariable("pg_trgm.strict_word_similarity_threshold",
                             "Sets the threshold used by the <<% operator.",
                             "Valid range is 0.0 .. 1.0.",
                             &strict_word_similarity_threshold,
                             0.5f,
                             0.0,
                             1.0,
                             PGC_USERSET,
                             0,
                             NULL,
                             NULL,
                             NULL);
 

References DefineCustomRealVariable(), fb(), MarkGUCPrefixReserved(), PGC_USERSET, similarity_threshold, strict_word_similarity_threshold, and word_similarity_threshold.

calc_word_similarity()

static float4 calc_word_similarity ( char *  str1, int  slen1, char *  str2, int  slen2, uint8  flags  )

static

Definition at line 814 of file trgm_op.c.

{
    bool       *found;
    pos_trgm   *ptrg;
    growable_trgm_array trg1;
    growable_trgm_array trg2;
    int         len1,
                len2,
                len,
                i,
                j,
                ulen1;
    int        *trg2indexes;
    float4      result;
    TrgmBound  *bounds = NULL;
 
    /* Make positional trigrams */
 
    generate_trgm_only(&trg1, str1, slen1, NULL);
    len1 = trg1.length;
    generate_trgm_only(&trg2, str2, slen2, (flags & WORD_SIMILARITY_STRICT) ? &bounds : NULL);
    len2 = trg2.length;
 
    ptrg = make_positional_trgm(GETARR(trg1.datum), len1, GETARR(trg2.datum), len2);
    len = len1 + len2;
    qsort(ptrg, len, sizeof(pos_trgm), comp_ptrgm);
 
    pfree(trg1.datum);
    pfree(trg2.datum);
 
    /*
     * Merge positional trigrams array: enumerate each trigram and find its
     * presence in required word.
     */
    trg2indexes = palloc_array(int, len2);
    found = palloc0_array(bool, len);
 
    ulen1 = 0;
    j = 0;
    for (i = 0; i < len; i++)
    {
        if (i > 0)
        {
            int         cmp = CMPTRGM(ptrg[i - 1].trg, ptrg[i].trg);
 
            if (cmp != 0)
            {
                if (found[j])
                    ulen1++;
                j++;
            }
        }
 
        if (ptrg[i].index >= 0)
        {
            trg2indexes[ptrg[i].index] = j;
        }
        else
        {
            found[j] = true;
        }
    }
    if (found[j])
        ulen1++;
 
    /* Run iterative procedure to find maximum similarity with word */
    result = iterate_word_similarity(trg2indexes, found, ulen1, len2, len,
                                     flags, bounds);
 
    pfree(trg2indexes);
    pfree(found);
    pfree(ptrg);
 

References cmp(), CMPTRGM, comp_ptrgm(), fb(), generate_trgm_only(), GETARR, i, iterate_word_similarity(), j, len, make_positional_trgm(), palloc0_array, palloc_array, pfree(), qsort, and WORD_SIMILARITY_STRICT.

Referenced by strict_word_similarity(), strict_word_similarity_commutator_op(), strict_word_similarity_dist_commutator_op(), strict_word_similarity_dist_op(), strict_word_similarity_op(), word_similarity(), word_similarity_commutator_op(), word_similarity_dist_commutator_op(), word_similarity_dist_op(), and word_similarity_op().

CMPTRGM_CHOOSE()

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

static

Definition at line 217 of file trgm_op.c.

{
    if (GetDefaultCharSignedness())
        CMPTRGM = CMPTRGM_SIGNED;
    else
        CMPTRGM = CMPTRGM_UNSIGNED;
 

References a, b, CMPTRGM, CMPTRGM_SIGNED(), CMPTRGM_UNSIGNED(), and GetDefaultCharSignedness().

CMPTRGM_SIGNED()

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

inlinestatic

Definition at line 193 of file trgm_op.c.

{
#define CMPPCHAR_S(a,b,i)  CMPCHAR( *(((const signed char*)(a))+i), *(((const signed char*)(b))+i) )
 
    return CMPPCHAR_S(a, b, 0) ? CMPPCHAR_S(a, b, 0)
        : (CMPPCHAR_S(a, b, 1) ? CMPPCHAR_S(a, b, 1)

References a, b, and CMPPCHAR_S.

Referenced by CMPTRGM_CHOOSE().

CMPTRGM_UNSIGNED()

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

inlinestatic

Definition at line 203 of file trgm_op.c.

{
#define CMPPCHAR_UNS(a,b,i)  CMPCHAR( *(((const unsigned char*)(a))+i), *(((const unsigned char*)(b))+i) )
 
    return CMPPCHAR_UNS(a, b, 0) ? CMPPCHAR_UNS(a, b, 0)
        : (CMPPCHAR_UNS(a, b, 1) ? CMPPCHAR_UNS(a, b, 1)

References a, b, and CMPPCHAR_UNS.

Referenced by CMPTRGM_CHOOSE().

cnt_sml()

float4 cnt_sml	(	TRGM *	trg1,
		TRGM *	trg2,
		bool	inexact
	)

Definition at line 1168 of file trgm_op.c.

{
    trgm       *ptr1,
               *ptr2;
    int         count = 0;
    int         len1,
                len2;
 
    ptr1 = GETARR(trg1);
    ptr2 = GETARR(trg2);
 
    len1 = ARRNELEM(trg1);
    len2 = ARRNELEM(trg2);
 
    /* explicit test is needed to avoid 0/0 division when both lengths are 0 */
    if (len1 <= 0 || len2 <= 0)
        return (float4) 0.0;
 
    while (ptr1 - GETARR(trg1) < len1 && ptr2 - GETARR(trg2) < len2)
    {
        int         res = CMPTRGM(ptr1, ptr2);
 
        if (res < 0)
            ptr1++;
        else if (res > 0)
            ptr2++;
        else
        {
            ptr1++;
            ptr2++;
            count++;
        }
    }
 
    /*
     * If inexact then len2 is equal to count, because we don't know actual
     * length of second string in inexact search and we can assume that count
     * is a lower bound of len2.
     */

References ARRNELEM, CALCSML, CMPTRGM, fb(), and GETARR.

Referenced by gtrgm_consistent(), gtrgm_distance(), and similarity().

comp_ptrgm()

static int comp_ptrgm ( const void *  v1, const void *  v2  )

static

Definition at line 617 of file trgm_op.c.

{
    const pos_trgm *p1 = (const pos_trgm *) v1;
    const pos_trgm *p2 = (const pos_trgm *) v2;
    int         cmp;
 
    cmp = CMPTRGM(p1->trg, p2->trg);
    if (cmp != 0)
        return cmp;
 

References cmp(), CMPTRGM, fb(), and pg_cmp_s32().

Referenced by calc_word_similarity().

comp_trgm()

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

static

Definition at line 283 of file trgm_op.c.

{

References a, b, and CMPTRGM.

Referenced by generate_trgm(), and generate_wildcard_trgm().

compact_trigram()

void compact_trigram	(	trgm *	tptr,
		char *	str,
		int	bytelen
	)

Definition at line 329 of file trgm_op.c.

{
    if (bytelen == 3)
    {
        CPTRGM(tptr, str);
    }
    else
    {
        pg_crc32    crc;
 
        INIT_LEGACY_CRC32(crc);
        COMP_LEGACY_CRC32(crc, str, bytelen);
        FIN_LEGACY_CRC32(crc);
 
        /*
         * use only 3 upper bytes from crc, hope, it's good enough hashing
         */
        CPTRGM(tptr, &crc);

References COMP_LEGACY_CRC32, CPTRGM, crc, fb(), FIN_LEGACY_CRC32, INIT_LEGACY_CRC32, and str.

Referenced by fillTrgm(), and make_trigrams().

enlarge_trgm_array()

static void enlarge_trgm_array ( growable_trgm_array *  arr, int  needed  )

static

Definition at line 122 of file trgm_op.c.

{
    size_t      new_needed = (size_t) arr->length + needed;
 
    if (new_needed > arr->allocated)
    {
        /* Guard against possible overflow, like in init_trgm_array */
        if (new_needed > MaxAllocSize / sizeof(trgm))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("out of memory")));
 
        arr->datum = repalloc(arr->datum, CALCGTSIZE(ARRKEY, new_needed));
        arr->allocated = new_needed;

References growable_trgm_array::allocated, ARRKEY, CALCGTSIZE, growable_trgm_array::datum, ereport, errcode(), errmsg(), ERROR, fb(), growable_trgm_array::length, MaxAllocSize, and repalloc().

Referenced by make_trigrams().

find_word()

static char * find_word ( char *  str, int  lenstr, char **  endword  )

static

Definition at line 293 of file trgm_op.c.

{
    char       *beginword = str;
    const char *endstr = str + lenstr;
 
    while (beginword < endstr)
    {
        int         clen = pg_mblen_range(beginword, endstr);
 
        if (ISWORDCHR(beginword, clen))
            break;
        beginword += clen;
    }
 
    if (beginword >= endstr)
        return NULL;
 
    *endword = beginword;
    while (*endword < endstr)
    {
        int         clen = pg_mblen_range(*endword, endstr);
 
        if (!ISWORDCHR(*endword, clen))
            break;
        *endword += clen;
    }
 

References fb(), ISWORDCHR, pg_mblen_range(), and str.

Referenced by generate_trgm_only().

generate_trgm()

TRGM * generate_trgm	(	char *	str,
		int	slen
	)

Definition at line 554 of file trgm_op.c.

{
    TRGM       *trg;
    growable_trgm_array arr;
    int         len;
 
    generate_trgm_only(&arr, str, slen, NULL);
    len = arr.length;
    trg = arr.datum;
    trg->flag = ARRKEY;
 
    /*
     * Make trigrams unique.
     */
    if (len > 1)
    {
        qsort(GETARR(trg), len, sizeof(trgm), comp_trgm);
        len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
    }
 
    SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len));
 

References ARRKEY, CALCGTSIZE, comp_trgm(), growable_trgm_array::datum, fb(), TRGM::flag, generate_trgm_only(), GETARR, len, growable_trgm_array::length, qsort, qunique(), SET_VARSIZE(), and str.

Referenced by gin_extract_query_trgm(), gin_extract_value_trgm(), gtrgm_compress(), gtrgm_consistent(), gtrgm_distance(), show_trgm(), and similarity().

generate_trgm_only()

static void generate_trgm_only ( growable_trgm_array *  dst, char *  str, int  slen, TrgmBound **  bounds_p  )

static

Definition at line 448 of file trgm_op.c.

{
    size_t      buflen;
    char       *buf;
    int         bytelen;
    char       *bword,
               *eword;
    TrgmBound  *bounds = NULL;
    int         bounds_allocated = 0;
 
    init_trgm_array(dst, slen);
 
    /*
     * If requested, allocate an array for the bounds, with the same size as
     * the trigram array.
     */
    if (bounds_p)
    {
        bounds_allocated = dst->allocated;
        bounds = *bounds_p = palloc0_array(TrgmBound, bounds_allocated);
    }
 
    if (slen + LPADDING + RPADDING < 3 || slen == 0)
        return;
 
    /*
     * Allocate a buffer for case-folded, blank-padded words.
     *
     * As an initial guess, allocate a buffer large enough to hold the
     * original string with padding, which is always enough when compiled with
     * !IGNORECASE.  If the case-folding produces a string longer than the
     * original, we'll grow the buffer.
     */
    buflen = (size_t) slen + 4;
    buf = (char *) palloc(buflen);
    if (LPADDING > 0)
    {
        *buf = ' ';
        if (LPADDING > 1)
            *(buf + 1) = ' ';
    }
 
    eword = str;
    while ((bword = find_word(eword, slen - (eword - str), &eword)) != NULL)
    {
        int         oldlen;
 
        /* Convert word to lower case before extracting trigrams from it */
#ifdef IGNORECASE
        {
            char       *lowered;
 
            lowered = str_tolower(bword, eword - bword, DEFAULT_COLLATION_OID);
            bytelen = strlen(lowered);
 
            /* grow the buffer if necessary */
            if (bytelen > buflen - 4)
            {
                pfree(buf);
                buflen = (size_t) bytelen + 4;
                buf = (char *) palloc(buflen);
                if (LPADDING > 0)
                {
                    *buf = ' ';
                    if (LPADDING > 1)
                        *(buf + 1) = ' ';
                }
            }
            memcpy(buf + LPADDING, lowered, bytelen);
            pfree(lowered);
        }
#else
        bytelen = eword - bword;
        memcpy(buf + LPADDING, bword, bytelen);
#endif
 
        buf[LPADDING + bytelen] = ' ';
        buf[LPADDING + bytelen + 1] = ' ';
 
        /* Calculate trigrams marking their bounds if needed */
        oldlen = dst->length;
        make_trigrams(dst, buf, bytelen + LPADDING + RPADDING);
        if (bounds)
        {
            if (bounds_allocated < dst->length)
            {
                bounds = *bounds_p = repalloc0_array(bounds, TrgmBound, bounds_allocated, dst->allocated);
                bounds_allocated = dst->allocated;
            }
 
            bounds[oldlen] |= TRGM_BOUND_LEFT;
            bounds[dst->length - 1] |= TRGM_BOUND_RIGHT;
        }
    }
 

References buf, fb(), find_word(), init_trgm_array(), LPADDING, make_trigrams(), palloc(), palloc0_array, pfree(), repalloc0_array, RPADDING, str, str_tolower(), TRGM_BOUND_LEFT, and TRGM_BOUND_RIGHT.

Referenced by calc_word_similarity(), and generate_trgm().

generate_wildcard_trgm()

TRGM * generate_wildcard_trgm	(	const char *	str,
		int	slen
	)

Definition at line 1044 of file trgm_op.c.

{
    TRGM       *trg;
    growable_trgm_array arr;
    char       *buf;
    int         len,
                bytelen;
    const char *eword;
 
    if (slen + LPADDING + RPADDING < 3 || slen == 0)
    {
        trg = (TRGM *) palloc(TRGMHDRSIZE);
        trg->flag = ARRKEY;
        SET_VARSIZE(trg, TRGMHDRSIZE);
        return trg;
    }
 
    init_trgm_array(&arr, slen);
 
    /* Allocate a buffer for blank-padded, but not yet case-folded, words */
    buf = palloc_array(char, slen + 4);
 
    /*
     * Extract trigrams from each substring extracted by get_wildcard_part.
     */
    eword = str;
    while ((eword = get_wildcard_part(eword, slen - (eword - str),
                                      buf, &bytelen)) != NULL)
    {
        char       *word;
 
#ifdef IGNORECASE
        word = str_tolower(buf, bytelen, DEFAULT_COLLATION_OID);
        bytelen = strlen(word);
#else
        word = buf;
#endif
 
        /*
         * count trigrams
         */
        make_trigrams(&arr, word, bytelen);
 
#ifdef IGNORECASE
        pfree(word);
#endif
    }
 
    pfree(buf);
 
    /*
     * Make trigrams unique.
     */
    trg = arr.datum;
    len = arr.length;
    if (len > 1)
    {
        qsort(GETARR(trg), len, sizeof(trgm), comp_trgm);
        len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
    }
 
    trg->flag = ARRKEY;
    SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len));
 

References ARRKEY, buf, CALCGTSIZE, comp_trgm(), growable_trgm_array::datum, fb(), TRGM::flag, get_wildcard_part(), GETARR, init_trgm_array(), len, growable_trgm_array::length, LPADDING, make_trigrams(), palloc(), palloc_array, pfree(), qsort, qunique(), RPADDING, SET_VARSIZE(), str, str_tolower(), TRGMHDRSIZE, and word().

Referenced by gin_extract_query_trgm(), and gtrgm_consistent().

get_wildcard_part()

static const char * get_wildcard_part ( const char *  str, int  lenstr, char *  buf, int *  bytelen  )

static

Definition at line 907 of file trgm_op.c.

{
    const char *beginword = str;
    const char *endword;
    const char *endstr = str + lenstr;
    char       *s = buf;
    bool        in_leading_wildcard_meta = false;
    bool        in_trailing_wildcard_meta = false;
    bool        in_escape = false;
    int         clen;
 
    /*
     * Find the first word character, remembering whether preceding character
     * was wildcard meta-character.  Note that the in_escape state persists
     * from this loop to the next one, since we may exit at a word character
     * that is in_escape.
     */
    while (beginword < endstr)
    {
        clen = pg_mblen_range(beginword, endstr);
 
        if (in_escape)
        {
            if (ISWORDCHR(beginword, clen))
                break;
            in_escape = false;
            in_leading_wildcard_meta = false;
        }
        else
        {
            if (ISESCAPECHAR(beginword))
                in_escape = true;
            else if (ISWILDCARDCHAR(beginword))
                in_leading_wildcard_meta = true;
            else if (ISWORDCHR(beginword, clen))
                break;
            else
                in_leading_wildcard_meta = false;
        }
        beginword += clen;
    }
 
    /*
     * Handle string end.
     */
    if (beginword - str >= lenstr)
        return NULL;
 
    /*
     * Add left padding spaces if preceding character wasn't wildcard
     * meta-character.
     */
    if (!in_leading_wildcard_meta)
    {
        if (LPADDING > 0)
        {
            *s++ = ' ';
            if (LPADDING > 1)
                *s++ = ' ';
        }
    }
 
    /*
     * Copy data into buf until wildcard meta-character, non-word character or
     * string boundary.  Strip escapes during copy.
     */
    endword = beginword;
    while (endword < endstr)
    {
        clen = pg_mblen_range(endword, endstr);
        if (in_escape)
        {
            if (ISWORDCHR(endword, clen))
            {
                memcpy(s, endword, clen);
                s += clen;
            }
            else
            {
                /*
                 * Back up endword to the escape character when stopping at an
                 * escaped char, so that subsequent get_wildcard_part will
                 * restart from the escape character.  We assume here that
                 * escape chars are single-byte.
                 */
                endword--;
                break;
            }
            in_escape = false;
        }
        else
        {
            if (ISESCAPECHAR(endword))
                in_escape = true;
            else if (ISWILDCARDCHAR(endword))
            {
                in_trailing_wildcard_meta = true;
                break;
            }
            else if (ISWORDCHR(endword, clen))
            {
                memcpy(s, endword, clen);
                s += clen;
            }
            else
                break;
        }
        endword += clen;
    }
 
    /*
     * Add right padding spaces if next character isn't wildcard
     * meta-character.
     */
    if (!in_trailing_wildcard_meta)
    {
        if (RPADDING > 0)
        {
            *s++ = ' ';
            if (RPADDING > 1)
                *s++ = ' ';
        }
    }
 
    *bytelen = s - buf;

References buf, fb(), ISESCAPECHAR, ISWILDCARDCHAR, ISWORDCHR, LPADDING, pg_mblen_range(), RPADDING, and str.

Referenced by generate_wildcard_trgm().

index_strategy_get_limit()

double index_strategy_get_limit

(

StrategyNumber

strategy

)

Definition at line 254 of file trgm_op.c.

{
    switch (strategy)
    {
        case SimilarityStrategyNumber:
            return similarity_threshold;
        case WordSimilarityStrategyNumber:
            return word_similarity_threshold;
        case StrictWordSimilarityStrategyNumber:
            return strict_word_similarity_threshold;
        default:
            elog(ERROR, "unrecognized strategy number: %d", strategy);
            break;
    }
 

References elog, ERROR, similarity_threshold, SimilarityStrategyNumber, strict_word_similarity_threshold, StrictWordSimilarityStrategyNumber, word_similarity_threshold, and WordSimilarityStrategyNumber.

Referenced by gin_trgm_consistent(), gin_trgm_triconsistent(), and gtrgm_consistent().

init_trgm_array()

static void init_trgm_array ( growable_trgm_array *  arr, int  slen  )

static

Definition at line 90 of file trgm_op.c.

{
    size_t      init_size;
 
    /*
     * In the extreme case, the input string consists entirely of one
     * character words, like "a b c", where each word is expanded to two
     * trigrams.  This is not a strict upper bound though, because when
     * IGNORECASE is defined, we convert the input string to lowercase before
     * extracting the trigrams, which in rare cases can expand one input
     * character into multiple characters.
     */
    init_size = (size_t) slen + 1;
 
    /*
     * Guard against possible overflow in the palloc request.  (We don't worry
     * about the additive constants, since palloc can detect requests that are
     * a little above MaxAllocSize --- we just need to prevent integer
     * overflow in the multiplications.)
     */
    if (init_size > MaxAllocSize / sizeof(trgm))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("out of memory")));
 
    arr->datum = palloc(CALCGTSIZE(ARRKEY, init_size));
    arr->allocated = init_size;

References growable_trgm_array::allocated, ARRKEY, CALCGTSIZE, growable_trgm_array::datum, ereport, errcode(), errmsg(), ERROR, fb(), growable_trgm_array::length, MaxAllocSize, and palloc().

Referenced by generate_trgm_only(), and generate_wildcard_trgm().

iterate_word_similarity()

static float4 iterate_word_similarity ( int *  trg2indexes, bool *  found, int  ulen1, int  len2, int  len, uint8  flags, TrgmBound *  bounds  )

static

Definition at line 646 of file trgm_op.c.

{
    int        *lastpos,
                i,
                ulen2 = 0,
                count = 0,
                upper = -1,
                lower;
    float4      smlr_cur,
                smlr_max = 0.0f;
    double      threshold;
 
    Assert(bounds || !(flags & WORD_SIMILARITY_STRICT));
 
    /* Select appropriate threshold */
    threshold = (flags & WORD_SIMILARITY_STRICT) ?
        strict_word_similarity_threshold :
        word_similarity_threshold;
 
    /*
     * Consider first trigram as initial lower bound for strict word
     * similarity, or initialize it later with first trigram present for plain
     * word similarity.
     */
    lower = (flags & WORD_SIMILARITY_STRICT) ? 0 : -1;
 
    /* Memorise last position of each trigram */
    lastpos = palloc_array(int, len);
    memset(lastpos, -1, sizeof(int) * len);
 
    for (i = 0; i < len2; i++)
    {
        int         trgindex;
 
        CHECK_FOR_INTERRUPTS();
 
        /* Get index of next trigram */
        trgindex = trg2indexes[i];
 
        /* Update last position of this trigram */
        if (lower >= 0 || found[trgindex])
        {
            if (lastpos[trgindex] < 0)
            {
                ulen2++;
                if (found[trgindex])
                    count++;
            }
            lastpos[trgindex] = i;
        }
 
        /*
         * Adjust upper bound if trigram is upper bound of word for strict
         * word similarity, or if trigram is present in required substring for
         * plain word similarity
         */
        if ((flags & WORD_SIMILARITY_STRICT) ? (bounds[i] & TRGM_BOUND_RIGHT)
            : found[trgindex])
        {
            int         prev_lower,
                        tmp_ulen2,
                        tmp_lower,
                        tmp_count;
 
            upper = i;
            if (lower == -1)
            {
                lower = i;
                ulen2 = 1;
            }
 
            smlr_cur = CALCSML(count, ulen1, ulen2);
 
            /* Also try to adjust lower bound for greater similarity */
            tmp_count = count;
            tmp_ulen2 = ulen2;
            prev_lower = lower;
            for (tmp_lower = lower; tmp_lower <= upper; tmp_lower++)
            {
                float       smlr_tmp;
                int         tmp_trgindex;
 
                /*
                 * Adjust lower bound only if trigram is lower bound of word
                 * for strict word similarity, or consider every trigram as
                 * lower bound for plain word similarity.
                 */
                if (!(flags & WORD_SIMILARITY_STRICT)
                    || (bounds[tmp_lower] & TRGM_BOUND_LEFT))
                {
                    smlr_tmp = CALCSML(tmp_count, ulen1, tmp_ulen2);
                    if (smlr_tmp > smlr_cur)
                    {
                        smlr_cur = smlr_tmp;
                        ulen2 = tmp_ulen2;
                        lower = tmp_lower;
                        count = tmp_count;
                    }
 
                    /*
                     * If we only check that word similarity is greater than
                     * threshold we do not need to calculate a maximum
                     * similarity.
                     */
                    if ((flags & WORD_SIMILARITY_CHECK_ONLY)
                        && smlr_cur >= threshold)
                        break;
                }
 
                tmp_trgindex = trg2indexes[tmp_lower];
                if (lastpos[tmp_trgindex] == tmp_lower)
                {
                    tmp_ulen2--;
                    if (found[tmp_trgindex])
                        tmp_count--;
                }
            }
 
            smlr_max = Max(smlr_max, smlr_cur);
 
            /*
             * if we only check that word similarity is greater than threshold
             * we do not need to calculate a maximum similarity.
             */
            if ((flags & WORD_SIMILARITY_CHECK_ONLY) && smlr_max >= threshold)
                break;
 
            for (tmp_lower = prev_lower; tmp_lower < lower; tmp_lower++)
            {
                int         tmp_trgindex;
 
                tmp_trgindex = trg2indexes[tmp_lower];
                if (lastpos[tmp_trgindex] == tmp_lower)
                    lastpos[tmp_trgindex] = -1;
            }
        }
    }
 
    pfree(lastpos);
 

References Assert, CALCSML, CHECK_FOR_INTERRUPTS, fb(), i, len, lower(), Max, palloc_array, pfree(), strict_word_similarity_threshold, TRGM_BOUND_LEFT, TRGM_BOUND_RIGHT, upper(), WORD_SIMILARITY_CHECK_ONLY, WORD_SIMILARITY_STRICT, and word_similarity_threshold.

Referenced by calc_word_similarity().

make_positional_trgm()

static pos_trgm * make_positional_trgm ( trgm *  trg1, int  len1, trgm *  trg2, int  len2  )

static

Definition at line 590 of file trgm_op.c.

{
    pos_trgm   *result;
    int         i,
                len = len1 + len2;
 
    result = palloc_array(pos_trgm, len);
 
    for (i = 0; i < len1; i++)
    {
        memcpy(&result[i].trg, &trg1[i], sizeof(trgm));
        result[i].index = -1;
    }
 
    for (i = 0; i < len2; i++)
    {
        memcpy(&result[i + len1].trg, &trg2[i], sizeof(trgm));
        result[i + len1].index = i;
    }
 

References fb(), i, pos_trgm::index, len, and palloc_array.

Referenced by calc_word_similarity().

make_trigrams()

static void make_trigrams ( growable_trgm_array *  dst, char *  str, int  bytelen  )

static

Definition at line 354 of file trgm_op.c.

{
    trgm       *tptr;
    char       *ptr = str;
 
    if (bytelen < 3)
        return;
 
    /* max number of trigrams = strlen - 2 */
    enlarge_trgm_array(dst, bytelen - 2);
    tptr = GETARR(dst->datum) + dst->length;
 
    if (pg_encoding_max_length(GetDatabaseEncoding()) == 1)
    {
        while (ptr < str + bytelen - 2)
        {
            CPTRGM(tptr, ptr);
            ptr++;
            tptr++;
        }
    }
    else
    {
        int         lenfirst,
                    lenmiddle,
                    lenlast;
        char       *endptr;
 
        /*
         * Fast path as long as there are no multibyte characters
         */
        if (!IS_HIGHBIT_SET(ptr[0]) && !IS_HIGHBIT_SET(ptr[1]))
        {
            while (!IS_HIGHBIT_SET(ptr[2]))
            {
                CPTRGM(tptr, ptr);
                ptr++;
                tptr++;
 
                if (ptr == str + bytelen - 2)
                    goto done;
            }
 
            lenfirst = 1;
            lenmiddle = 1;
            lenlast = pg_mblen_unbounded(ptr + 2);
        }
        else
        {
            lenfirst = pg_mblen_unbounded(ptr);
            if (ptr + lenfirst >= str + bytelen)
                goto done;
            lenmiddle = pg_mblen_unbounded(ptr + lenfirst);
            if (ptr + lenfirst + lenmiddle >= str + bytelen)
                goto done;
            lenlast = pg_mblen_unbounded(ptr + lenfirst + lenmiddle);
        }
 
        /*
         * Slow path to handle any remaining multibyte characters
         *
         * As we go, 'ptr' points to the beginning of the current
         * three-character string and 'endptr' points to just past it.
         */
        endptr = ptr + lenfirst + lenmiddle + lenlast;
        while (endptr <= str + bytelen)
        {
            compact_trigram(tptr, ptr, endptr - ptr);
            tptr++;
 
            /* Advance to the next character */
            if (endptr == str + bytelen)
                break;
            ptr += lenfirst;
            lenfirst = lenmiddle;
            lenmiddle = lenlast;
            lenlast = pg_mblen_unbounded(endptr);
            endptr += lenlast;
        }
    }
 
done:
    dst->length = tptr - GETARR(dst->datum);

References Assert, compact_trigram(), CPTRGM, enlarge_trgm_array(), fb(), GETARR, GetDatabaseEncoding(), IS_HIGHBIT_SET, pg_encoding_max_length(), pg_mblen_unbounded(), and str.

Referenced by generate_trgm_only(), and generate_wildcard_trgm().

PG_FUNCTION_INFO_V1() [1/16]

PG_FUNCTION_INFO_V1

(

set_limit

)

PG_FUNCTION_INFO_V1() [2/16]

PG_FUNCTION_INFO_V1

(

show_limit

)

PG_FUNCTION_INFO_V1() [3/16]

PG_FUNCTION_INFO_V1

(

show_trgm

)

PG_FUNCTION_INFO_V1() [4/16]

PG_FUNCTION_INFO_V1

(

similarity

)

PG_FUNCTION_INFO_V1() [5/16]

PG_FUNCTION_INFO_V1

(

similarity_dist

)

PG_FUNCTION_INFO_V1() [6/16]

PG_FUNCTION_INFO_V1

(

similarity_op

)

PG_FUNCTION_INFO_V1() [7/16]

PG_FUNCTION_INFO_V1

(

strict_word_similarity

)

PG_FUNCTION_INFO_V1() [8/16]

PG_FUNCTION_INFO_V1

(

strict_word_similarity_commutator_op

)

PG_FUNCTION_INFO_V1() [9/16]

PG_FUNCTION_INFO_V1

(

strict_word_similarity_dist_commutator_op

)

PG_FUNCTION_INFO_V1() [10/16]

PG_FUNCTION_INFO_V1

(

strict_word_similarity_dist_op

)

PG_FUNCTION_INFO_V1() [11/16]

PG_FUNCTION_INFO_V1

(

strict_word_similarity_op

)

PG_FUNCTION_INFO_V1() [12/16]

PG_FUNCTION_INFO_V1

(

word_similarity

)

PG_FUNCTION_INFO_V1() [13/16]

PG_FUNCTION_INFO_V1

(

word_similarity_commutator_op

)

PG_FUNCTION_INFO_V1() [14/16]

PG_FUNCTION_INFO_V1

(

word_similarity_dist_commutator_op

)

PG_FUNCTION_INFO_V1() [15/16]

PG_FUNCTION_INFO_V1

(

word_similarity_dist_op

)

PG_FUNCTION_INFO_V1() [16/16]

PG_FUNCTION_INFO_V1

(

word_similarity_op

)

PG_MODULE_MAGIC_EXT()

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

set_limit()

Datum set_limit

(

PG_FUNCTION_ARGS

)

Definition at line 232 of file trgm_op.c.

{
    float4      nlimit = PG_GETARG_FLOAT4(0);
    char       *nlimit_str;
    Oid         func_out_oid;
    bool        is_varlena;
 
    getTypeOutputInfo(FLOAT4OID, &func_out_oid, &is_varlena);
 
    nlimit_str = OidOutputFunctionCall(func_out_oid, Float4GetDatum(nlimit));
 
    SetConfigOption("pg_trgm.similarity_threshold", nlimit_str,
                    PGC_USERSET, PGC_S_SESSION);
 

References fb(), Float4GetDatum(), getTypeOutputInfo(), OidOutputFunctionCall(), PG_GETARG_FLOAT4, PG_RETURN_FLOAT4, PGC_S_SESSION, PGC_USERSET, SetConfigOption(), and similarity_threshold.

show_limit()

Datum show_limit

(

PG_FUNCTION_ARGS

)

Definition at line 277 of file trgm_op.c.

{

References PG_RETURN_FLOAT4, and similarity_threshold.

show_trgm()

Datum show_trgm

(

PG_FUNCTION_ARGS

)

Definition at line 1126 of file trgm_op.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    TRGM       *trg;
    Datum      *d;
    ArrayType  *a;
    trgm       *ptr;
    int         i;
 
    trg = generate_trgm(VARDATA_ANY(in), VARSIZE_ANY_EXHDR(in));
    d = palloc_array(Datum, 1 + ARRNELEM(trg));
 
    for (i = 0, ptr = GETARR(trg); i < ARRNELEM(trg); i++, ptr++)
    {
        text       *item = (text *) palloc(VARHDRSZ + Max(12, pg_database_encoding_max_length() * 3));
 
        if (pg_database_encoding_max_length() > 1 && !ISPRINTABLETRGM(ptr))
        {
            snprintf(VARDATA(item), 12, "0x%06x", trgm2int(ptr));
            SET_VARSIZE(item, VARHDRSZ + strlen(VARDATA(item)));
        }
        else
        {
            SET_VARSIZE(item, VARHDRSZ + 3);
            CPTRGM(VARDATA(item), ptr);
        }
        d[i] = PointerGetDatum(item);
    }
 
    a = construct_array_builtin(d, ARRNELEM(trg), TEXTOID);
 
    for (i = 0; i < ARRNELEM(trg); i++)
        pfree(DatumGetPointer(d[i]));
 
    pfree(d);
    pfree(trg);
    PG_FREE_IF_COPY(in, 0);
 

References a, ARRNELEM, construct_array_builtin(), CPTRGM, DatumGetPointer(), fb(), generate_trgm(), GETARR, i, ISPRINTABLETRGM, Max, palloc(), palloc_array, pfree(), pg_database_encoding_max_length(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_POINTER, PointerGetDatum(), SET_VARSIZE(), snprintf, trgm2int(), VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

similarity()

Datum similarity

(

PG_FUNCTION_ARGS

)

Definition at line 1294 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    TRGM       *trg1,
               *trg2;
    float4      res;
 
    trg1 = generate_trgm(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1));
    trg2 = generate_trgm(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2));
 
    res = cnt_sml(trg1, trg2, false);
 
    pfree(trg1);
    pfree(trg2);
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);
 

References cnt_sml(), fb(), generate_trgm(), pfree(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by similarity_dist(), and similarity_op().

similarity_dist()

Datum similarity_dist

(

PG_FUNCTION_ARGS

)

Definition at line 1348 of file trgm_op.c.

{
    float4      res = DatumGetFloat4(DirectFunctionCall2(similarity,
                                                         PG_GETARG_DATUM(0),
                                                         PG_GETARG_DATUM(1)));
 

References DatumGetFloat4(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_FLOAT4, and similarity().

similarity_op()

Datum similarity_op

(

PG_FUNCTION_ARGS

)

Definition at line 1358 of file trgm_op.c.

{
    float4      res = DatumGetFloat4(DirectFunctionCall2(similarity,
                                                         PG_GETARG_DATUM(0),
                                                         PG_GETARG_DATUM(1)));
 

References DatumGetFloat4(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, similarity(), and similarity_threshold.

strict_word_similarity()

Datum strict_word_similarity

(

PG_FUNCTION_ARGS

)

Definition at line 1332 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               WORD_SIMILARITY_STRICT);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and WORD_SIMILARITY_STRICT.

strict_word_similarity_commutator_op()

Datum strict_word_similarity_commutator_op

(

PG_FUNCTION_ARGS

)

Definition at line 1448 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               WORD_SIMILARITY_CHECK_ONLY | WORD_SIMILARITY_STRICT);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, strict_word_similarity_threshold, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WORD_SIMILARITY_CHECK_ONLY, and WORD_SIMILARITY_STRICT.

strict_word_similarity_dist_commutator_op()

Datum strict_word_similarity_dist_commutator_op

(

PG_FUNCTION_ARGS

)

Definition at line 1480 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               WORD_SIMILARITY_STRICT);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and WORD_SIMILARITY_STRICT.

strict_word_similarity_dist_op()

Datum strict_word_similarity_dist_op

(

PG_FUNCTION_ARGS

)

Definition at line 1464 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               WORD_SIMILARITY_STRICT);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and WORD_SIMILARITY_STRICT.

strict_word_similarity_op()

Datum strict_word_similarity_op

(

PG_FUNCTION_ARGS

)

Definition at line 1432 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               WORD_SIMILARITY_CHECK_ONLY | WORD_SIMILARITY_STRICT);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, strict_word_similarity_threshold, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WORD_SIMILARITY_CHECK_ONLY, and WORD_SIMILARITY_STRICT.

trgm2int()

uint32 trgm2int

(

trgm *

ptr

)

Definition at line 1112 of file trgm_op.c.

{
    uint32      val = 0;
 
    val |= *(((unsigned char *) ptr));
    val <<= 8;
    val |= *(((unsigned char *) ptr) + 1);
    val <<= 8;
    val |= *(((unsigned char *) ptr) + 2);
 

References val.

Referenced by gin_extract_query_trgm(), gin_extract_value_trgm(), and show_trgm().

trgm_contained_by()

bool trgm_contained_by	(	TRGM *	trg1,
		TRGM *	trg2
	)

Definition at line 1216 of file trgm_op.c.

{
    trgm       *ptr1,
               *ptr2;
    int         len1,
                len2;
 
    ptr1 = GETARR(trg1);
    ptr2 = GETARR(trg2);
 
    len1 = ARRNELEM(trg1);
    len2 = ARRNELEM(trg2);
 
    while (ptr1 - GETARR(trg1) < len1 && ptr2 - GETARR(trg2) < len2)
    {
        int         res = CMPTRGM(ptr1, ptr2);
 
        if (res < 0)
            return false;
        else if (res > 0)
            ptr2++;
        else
        {
            ptr1++;
            ptr2++;
        }
    }
    if (ptr1 - GETARR(trg1) < len1)
        return false;
    else

References ARRNELEM, CMPTRGM, fb(), and GETARR.

Referenced by gtrgm_consistent().

trgm_presence_map()

bool * trgm_presence_map	(	TRGM *	query,
		TRGM *	key
	)

Definition at line 1255 of file trgm_op.c.

{
    bool       *result;
    trgm       *ptrq = GETARR(query),
               *ptrk = GETARR(key);
    int         lenq = ARRNELEM(query),
                lenk = ARRNELEM(key),
                i;
 
    result = palloc0_array(bool, lenq);
 
    /* for each query trigram, do a binary search in the key array */
    for (i = 0; i < lenq; i++)
    {
        int         lo = 0;
        int         hi = lenk;
 
        while (lo < hi)
        {
            int         mid = (lo + hi) / 2;
            int         res = CMPTRGM(ptrq, ptrk + mid);
 
            if (res < 0)
                hi = mid;
            else if (res > 0)
                lo = mid + 1;
            else
            {
                result[i] = true;
                break;
            }
        }
        ptrq++;
    }
 

References ARRNELEM, CMPTRGM, fb(), GETARR, i, and palloc0_array.

Referenced by gtrgm_consistent().

word_similarity()

Datum word_similarity

(

PG_FUNCTION_ARGS

)

Definition at line 1316 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               0);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

word_similarity_commutator_op()

Datum word_similarity_commutator_op

(

PG_FUNCTION_ARGS

)

Definition at line 1384 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               WORD_SIMILARITY_CHECK_ONLY);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WORD_SIMILARITY_CHECK_ONLY, and word_similarity_threshold.

word_similarity_dist_commutator_op()

Datum word_similarity_dist_commutator_op

(

PG_FUNCTION_ARGS

)

Definition at line 1416 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               0);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

word_similarity_dist_op()

Datum word_similarity_dist_op

(

PG_FUNCTION_ARGS

)

Definition at line 1400 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               0);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_FLOAT4, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

word_similarity_op()

Datum word_similarity_op

(

PG_FUNCTION_ARGS

)

Definition at line 1368 of file trgm_op.c.

{
    text       *in1 = PG_GETARG_TEXT_PP(0);
    text       *in2 = PG_GETARG_TEXT_PP(1);
    float4      res;
 
    res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
                               VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
                               WORD_SIMILARITY_CHECK_ONLY);
 
    PG_FREE_IF_COPY(in1, 0);
    PG_FREE_IF_COPY(in2, 1);

References calc_word_similarity(), fb(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WORD_SIMILARITY_CHECK_ONLY, and word_similarity_threshold.

Variable Documentation

CMPTRGM

int(* CMPTRGM) (const void *a, const void *b)	(	const void *	a,
		const void *	b
	)		= CMPTRGM_CHOOSE

Definition at line 49 of file trgm_op.c.

Referenced by calc_word_similarity(), CMPTRGM_CHOOSE(), cnt_sml(), comp_ptrgm(), comp_trgm(), gtrgm_same(), trgm_contained_by(), and trgm_presence_map().

similarity_threshold

double similarity_threshold = 0.3f

Definition at line 27 of file trgm_op.c.

Referenced by _PG_init(), index_strategy_get_limit(), set_limit(), show_limit(), and similarity_op().

strict_word_similarity_threshold

double strict_word_similarity_threshold = 0.5f

Definition at line 29 of file trgm_op.c.

Referenced by _PG_init(), index_strategy_get_limit(), iterate_word_similarity(), strict_word_similarity_commutator_op(), and strict_word_similarity_op().

word_similarity_threshold

double word_similarity_threshold = 0.6f

Definition at line 28 of file trgm_op.c.

Referenced by _PG_init(), index_strategy_get_limit(), iterate_word_similarity(), word_similarity_commutator_op(), and word_similarity_op().