284 lines
8.8 KiB
C
284 lines
8.8 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* ts_utils.h
|
|
* helper utilities for tsearch
|
|
*
|
|
* Copyright (c) 1998-2024, PostgreSQL Global Development Group
|
|
*
|
|
* src/include/tsearch/ts_utils.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef _PG_TS_UTILS_H_
|
|
#define _PG_TS_UTILS_H_
|
|
|
|
#include "nodes/pg_list.h"
|
|
#include "tsearch/ts_public.h"
|
|
#include "tsearch/ts_type.h"
|
|
|
|
/*
|
|
* Common parse definitions for tsvector and tsquery
|
|
*/
|
|
|
|
/* tsvector parser support. */
|
|
|
|
struct TSVectorParseStateData; /* opaque struct in tsvector_parser.c */
|
|
typedef struct TSVectorParseStateData *TSVectorParseState;
|
|
|
|
/* flag bits that can be passed to init_tsvector_parser: */
|
|
#define P_TSV_OPR_IS_DELIM (1 << 0)
|
|
#define P_TSV_IS_TSQUERY (1 << 1)
|
|
#define P_TSV_IS_WEB (1 << 2)
|
|
|
|
extern TSVectorParseState init_tsvector_parser(char *input, int flags,
|
|
Node *escontext);
|
|
extern void reset_tsvector_parser(TSVectorParseState state, char *input);
|
|
extern bool gettoken_tsvector(TSVectorParseState state,
|
|
char **strval, int *lenval,
|
|
WordEntryPos **pos_ptr, int *poslen,
|
|
char **endptr);
|
|
extern void close_tsvector_parser(TSVectorParseState state);
|
|
|
|
/* phrase operator begins with '<' */
|
|
#define ISOPERATOR(x) \
|
|
( pg_mblen(x) == 1 && ( *(x) == '!' || \
|
|
*(x) == '&' || \
|
|
*(x) == '|' || \
|
|
*(x) == '(' || \
|
|
*(x) == ')' || \
|
|
*(x) == '<' \
|
|
) )
|
|
|
|
/* parse_tsquery */
|
|
|
|
struct TSQueryParserStateData; /* private in backend/utils/adt/tsquery.c */
|
|
typedef struct TSQueryParserStateData *TSQueryParserState;
|
|
|
|
typedef void (*PushFunction) (Datum opaque, TSQueryParserState state,
|
|
char *token, int tokenlen,
|
|
int16 tokenweights, /* bitmap as described in
|
|
* QueryOperand struct */
|
|
bool prefix);
|
|
|
|
/* flag bits that can be passed to parse_tsquery: */
|
|
#define P_TSQ_PLAIN (1 << 0)
|
|
#define P_TSQ_WEB (1 << 1)
|
|
|
|
extern TSQuery parse_tsquery(char *buf,
|
|
PushFunction pushval,
|
|
Datum opaque,
|
|
int flags,
|
|
Node *escontext);
|
|
|
|
/* Functions for use by PushFunction implementations */
|
|
extern void pushValue(TSQueryParserState state,
|
|
char *strval, int lenval, int16 weight, bool prefix);
|
|
extern void pushStop(TSQueryParserState state);
|
|
extern void pushOperator(TSQueryParserState state, int8 oper, int16 distance);
|
|
|
|
/*
|
|
* parse plain text and lexize words
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint16 flags; /* currently, only TSL_PREFIX */
|
|
uint16 len;
|
|
uint16 nvariant;
|
|
uint16 alen;
|
|
union
|
|
{
|
|
uint16 pos;
|
|
|
|
/*
|
|
* When apos array is used, apos[0] is the number of elements in the
|
|
* array (excluding apos[0]), and alen is the allocated size of the
|
|
* array. We do not allow more than MAXNUMPOS array elements.
|
|
*/
|
|
uint16 *apos;
|
|
} pos;
|
|
char *word;
|
|
} ParsedWord;
|
|
|
|
typedef struct
|
|
{
|
|
ParsedWord *words;
|
|
int32 lenwords;
|
|
int32 curwords;
|
|
int32 pos;
|
|
} ParsedText;
|
|
|
|
extern void parsetext(Oid cfgId, ParsedText *prs, char *buf, int32 buflen);
|
|
|
|
/*
|
|
* headline framework, flow in common to generate:
|
|
* 1 parse text with hlparsetext
|
|
* 2 parser-specific function to find part
|
|
* 3 generateHeadline to generate result text
|
|
*/
|
|
|
|
extern void hlparsetext(Oid cfgId, HeadlineParsedText *prs, TSQuery query,
|
|
char *buf, int32 buflen);
|
|
extern text *generateHeadline(HeadlineParsedText *prs);
|
|
|
|
/*
|
|
* TSQuery execution support
|
|
*
|
|
* TS_execute() executes a tsquery against data that can be represented in
|
|
* various forms. The TSExecuteCallback callback function is called to check
|
|
* whether a given primitive tsquery value is matched in the data.
|
|
*/
|
|
|
|
/* TS_execute requires ternary logic to handle NOT with phrase matches */
|
|
typedef enum
|
|
{
|
|
TS_NO, /* definitely no match */
|
|
TS_YES, /* definitely does match */
|
|
TS_MAYBE, /* can't verify match for lack of pos data */
|
|
} TSTernaryValue;
|
|
|
|
/*
|
|
* struct ExecPhraseData is passed to a TSExecuteCallback function if we need
|
|
* lexeme position data (because of a phrase-match operator in the tsquery).
|
|
* The callback should fill in position data when it returns TS_YES (success).
|
|
* If it cannot return position data, it should leave "data" unchanged and
|
|
* return TS_MAYBE. The caller of TS_execute() must then arrange for a later
|
|
* recheck with position data available.
|
|
*
|
|
* The reported lexeme positions must be sorted and unique. Callers must only
|
|
* consult the position bits of the pos array, ie, WEP_GETPOS(data->pos[i]).
|
|
* This allows the returned "pos" to point directly to the WordEntryPos
|
|
* portion of a tsvector value. If "allocated" is true then the pos array
|
|
* is palloc'd workspace and caller may free it when done.
|
|
*
|
|
* "negate" means that the pos array contains positions where the query does
|
|
* not match, rather than positions where it does. "width" is positive when
|
|
* the match is wider than one lexeme. Neither of these fields normally need
|
|
* to be touched by TSExecuteCallback functions; they are used for
|
|
* phrase-search processing within TS_execute.
|
|
*
|
|
* All fields of the ExecPhraseData struct are initially zeroed by caller.
|
|
*/
|
|
typedef struct ExecPhraseData
|
|
{
|
|
int npos; /* number of positions reported */
|
|
bool allocated; /* pos points to palloc'd data? */
|
|
bool negate; /* positions are where query is NOT matched */
|
|
WordEntryPos *pos; /* ordered, non-duplicate lexeme positions */
|
|
int width; /* width of match in lexemes, less 1 */
|
|
} ExecPhraseData;
|
|
|
|
/*
|
|
* Signature for TSQuery lexeme check functions
|
|
*
|
|
* arg: opaque value passed through from caller of TS_execute
|
|
* val: lexeme to test for presence of
|
|
* data: to be filled with lexeme positions; NULL if position data not needed
|
|
*
|
|
* Return TS_YES if lexeme is present in data, TS_MAYBE if it might be
|
|
* present, TS_NO if it definitely is not present. If data is not NULL,
|
|
* it must be filled with lexeme positions if available. If position data
|
|
* is not available, leave *data as zeroes and return TS_MAYBE, never TS_YES.
|
|
*/
|
|
typedef TSTernaryValue (*TSExecuteCallback) (void *arg, QueryOperand *val,
|
|
ExecPhraseData *data);
|
|
|
|
/*
|
|
* Flag bits for TS_execute
|
|
*/
|
|
#define TS_EXEC_EMPTY (0x00)
|
|
/*
|
|
* If TS_EXEC_SKIP_NOT is set, then NOT sub-expressions are automatically
|
|
* evaluated to be true. This was formerly the default behavior. It's now
|
|
* deprecated because it tends to give silly answers, but some applications
|
|
* might still have a use for it.
|
|
*/
|
|
#define TS_EXEC_SKIP_NOT (0x01)
|
|
/*
|
|
* If TS_EXEC_PHRASE_NO_POS is set, allow OP_PHRASE to be executed lossily
|
|
* in the absence of position information: a true result indicates that the
|
|
* phrase might be present. Without this flag, OP_PHRASE always returns
|
|
* false if lexeme position information is not available.
|
|
*/
|
|
#define TS_EXEC_PHRASE_NO_POS (0x02)
|
|
|
|
extern bool TS_execute(QueryItem *curitem, void *arg, uint32 flags,
|
|
TSExecuteCallback chkcond);
|
|
extern TSTernaryValue TS_execute_ternary(QueryItem *curitem, void *arg,
|
|
uint32 flags,
|
|
TSExecuteCallback chkcond);
|
|
extern List *TS_execute_locations(QueryItem *curitem, void *arg,
|
|
uint32 flags,
|
|
TSExecuteCallback chkcond);
|
|
extern bool tsquery_requires_match(QueryItem *curitem);
|
|
|
|
/*
|
|
* to_ts* - text transformation to tsvector, tsquery
|
|
*/
|
|
extern TSVector make_tsvector(ParsedText *prs);
|
|
extern int32 tsCompareString(char *a, int lena, char *b, int lenb, bool prefix);
|
|
|
|
/*
|
|
* Possible strategy numbers for indexes
|
|
* TSearchStrategyNumber - (tsvector|text) @@ tsquery
|
|
* TSearchWithClassStrategyNumber - tsvector @@@ tsquery
|
|
*/
|
|
#define TSearchStrategyNumber 1
|
|
#define TSearchWithClassStrategyNumber 2
|
|
|
|
/*
|
|
* TSQuery Utilities
|
|
*/
|
|
extern QueryItem *clean_NOT(QueryItem *ptr, int32 *len);
|
|
extern TSQuery cleanup_tsquery_stopwords(TSQuery in, bool noisy);
|
|
|
|
typedef struct QTNode
|
|
{
|
|
QueryItem *valnode;
|
|
uint32 flags;
|
|
int32 nchild;
|
|
char *word;
|
|
uint32 sign;
|
|
struct QTNode **child;
|
|
} QTNode;
|
|
|
|
/* bits in QTNode.flags */
|
|
#define QTN_NEEDFREE 0x01
|
|
#define QTN_NOCHANGE 0x02
|
|
#define QTN_WORDFREE 0x04
|
|
|
|
typedef uint64 TSQuerySign;
|
|
|
|
#define TSQS_SIGLEN (sizeof(TSQuerySign)*BITS_PER_BYTE)
|
|
|
|
static inline Datum
|
|
TSQuerySignGetDatum(TSQuerySign X)
|
|
{
|
|
return Int64GetDatum((int64) X);
|
|
}
|
|
|
|
static inline TSQuerySign
|
|
DatumGetTSQuerySign(Datum X)
|
|
{
|
|
return (TSQuerySign) DatumGetInt64(X);
|
|
}
|
|
|
|
#define PG_RETURN_TSQUERYSIGN(X) return TSQuerySignGetDatum(X)
|
|
#define PG_GETARG_TSQUERYSIGN(n) DatumGetTSQuerySign(PG_GETARG_DATUM(n))
|
|
|
|
|
|
extern QTNode *QT2QTN(QueryItem *in, char *operand);
|
|
extern TSQuery QTN2QT(QTNode *in);
|
|
extern void QTNFree(QTNode *in);
|
|
extern void QTNSort(QTNode *in);
|
|
extern void QTNTernary(QTNode *in);
|
|
extern void QTNBinary(QTNode *in);
|
|
extern int QTNodeCompare(QTNode *an, QTNode *bn);
|
|
extern QTNode *QTNCopy(QTNode *in);
|
|
extern void QTNClearFlags(QTNode *in, uint32 flags);
|
|
extern bool QTNEq(QTNode *a, QTNode *b);
|
|
extern TSQuerySign makeTSQuerySign(TSQuery a);
|
|
extern QTNode *findsubquery(QTNode *root, QTNode *ex, QTNode *subs,
|
|
bool *isfind);
|
|
|
|
#endif /* _PG_TS_UTILS_H_ */
|