PostgreSQL Source Code  git master
tsginidx.c File Reference
#include "postgres.h"
#include "access/gin.h"
#include "access/stratnum.h"
#include "miscadmin.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
#include "varatt.h"
Include dependency graph for tsginidx.c:

Go to the source code of this file.

Data Structures

struct  GinChkVal
 

Functions

Datum gin_cmp_tslexeme (PG_FUNCTION_ARGS)
 
Datum gin_cmp_prefix (PG_FUNCTION_ARGS)
 
Datum gin_extract_tsvector (PG_FUNCTION_ARGS)
 
Datum gin_extract_tsquery (PG_FUNCTION_ARGS)
 
static TSTernaryValue checkcondition_gin (void *checkval, QueryOperand *val, ExecPhraseData *data)
 
Datum gin_tsquery_consistent (PG_FUNCTION_ARGS)
 
Datum gin_tsquery_triconsistent (PG_FUNCTION_ARGS)
 
Datum gin_extract_tsvector_2args (PG_FUNCTION_ARGS)
 
Datum gin_extract_tsquery_5args (PG_FUNCTION_ARGS)
 
Datum gin_tsquery_consistent_6args (PG_FUNCTION_ARGS)
 
Datum gin_extract_tsquery_oldsig (PG_FUNCTION_ARGS)
 
Datum gin_tsquery_consistent_oldsig (PG_FUNCTION_ARGS)
 

Function Documentation

◆ checkcondition_gin()

static TSTernaryValue checkcondition_gin ( void *  checkval,
QueryOperand val,
ExecPhraseData data 
)
static

Definition at line 185 of file tsginidx.c.

186 {
187  GinChkVal *gcv = (GinChkVal *) checkval;
188  int j;
189  GinTernaryValue result;
190 
191  /* convert item's number to corresponding entry's (operand's) number */
192  j = gcv->map_item_operand[((QueryItem *) val) - gcv->first_item];
193 
194  /* determine presence of current entry in indexed value */
195  result = gcv->check[j];
196 
197  /*
198  * If any val requiring a weight is used or caller needs position
199  * information then we must recheck, so replace TRUE with MAYBE.
200  */
201  if (result == GIN_TRUE)
202  {
203  if (val->weight != 0 || data != NULL)
204  result = GIN_MAYBE;
205  }
206 
207  /*
208  * We rely on GinTernaryValue and TSTernaryValue using equivalent value
209  * assignments. We could use a switch statement to map the values if that
210  * ever stops being true, but it seems unlikely to happen.
211  */
212  return (TSTernaryValue) result;
213 }
char GinTernaryValue
Definition: gin.h:58
#define GIN_MAYBE
Definition: gin.h:65
#define GIN_TRUE
Definition: gin.h:64
long val
Definition: informix.c:664
int j
Definition: isn.c:74
const void * data
QueryItem * first_item
Definition: tsginidx.c:176
GinTernaryValue * check
Definition: tsginidx.c:177
int * map_item_operand
Definition: tsginidx.c:178
TSTernaryValue
Definition: ts_utils.h:133

References GinChkVal::check, data, GinChkVal::first_item, GIN_MAYBE, GIN_TRUE, j, GinChkVal::map_item_operand, and val.

Referenced by gin_tsquery_consistent(), and gin_tsquery_triconsistent().

◆ gin_cmp_prefix()

Datum gin_cmp_prefix ( PG_FUNCTION_ARGS  )

Definition at line 42 of file tsginidx.c.

43 {
44  text *a = PG_GETARG_TEXT_PP(0);
45  text *b = PG_GETARG_TEXT_PP(1);
46 
47 #ifdef NOT_USED
48  StrategyNumber strategy = PG_GETARG_UINT16(2);
49  Pointer extra_data = PG_GETARG_POINTER(3);
50 #endif
51  int cmp;
52 
55  true);
56 
57  if (cmp < 0)
58  cmp = 1; /* prevent continue scan */
59 
60  PG_FREE_IF_COPY(a, 0);
61  PG_FREE_IF_COPY(b, 1);
63 }
char * Pointer
Definition: c.h:472
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:260
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define PG_GETARG_UINT16(n)
Definition: fmgr.h:272
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
int b
Definition: isn.c:70
int a
Definition: isn.c:69
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:743
uint16 StrategyNumber
Definition: stratnum.h:22
Definition: c.h:676
int32 tsCompareString(char *a, int lena, char *b, int lenb, bool prefix)
Definition: tsvector_op.c:1154
#define VARDATA_ANY(PTR)
Definition: varatt.h:324
#define VARSIZE_ANY_EXHDR(PTR)
Definition: varatt.h:317

References a, b, cmp(), PG_FREE_IF_COPY, PG_GETARG_POINTER, PG_GETARG_TEXT_PP, PG_GETARG_UINT16, PG_RETURN_INT32, tsCompareString(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ gin_cmp_tslexeme()

Datum gin_cmp_tslexeme ( PG_FUNCTION_ARGS  )

Definition at line 26 of file tsginidx.c.

27 {
28  text *a = PG_GETARG_TEXT_PP(0);
29  text *b = PG_GETARG_TEXT_PP(1);
30  int cmp;
31 
34  false);
35 
36  PG_FREE_IF_COPY(a, 0);
37  PG_FREE_IF_COPY(b, 1);
39 }

References a, b, cmp(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_INT32, tsCompareString(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ gin_extract_tsquery()

Datum gin_extract_tsquery ( PG_FUNCTION_ARGS  )

Definition at line 96 of file tsginidx.c.

97 {
98  TSQuery query = PG_GETARG_TSQUERY(0);
99  int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
100 
101  /* StrategyNumber strategy = PG_GETARG_UINT16(2); */
102  bool **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3);
103  Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
104 
105  /* bool **nullFlags = (bool **) PG_GETARG_POINTER(5); */
106  int32 *searchMode = (int32 *) PG_GETARG_POINTER(6);
107  Datum *entries = NULL;
108 
109  *nentries = 0;
110 
111  if (query->size > 0)
112  {
113  QueryItem *item = GETQUERY(query);
114  int32 i,
115  j;
116  bool *partialmatch;
117  int *map_item_operand;
118 
119  /*
120  * If the query doesn't have any required positive matches (for
121  * instance, it's something like '! foo'), we have to do a full index
122  * scan.
123  */
124  if (tsquery_requires_match(item))
125  *searchMode = GIN_SEARCH_MODE_DEFAULT;
126  else
127  *searchMode = GIN_SEARCH_MODE_ALL;
128 
129  /* count number of VAL items */
130  j = 0;
131  for (i = 0; i < query->size; i++)
132  {
133  if (item[i].type == QI_VAL)
134  j++;
135  }
136  *nentries = j;
137 
138  entries = (Datum *) palloc(sizeof(Datum) * j);
139  partialmatch = *ptr_partialmatch = (bool *) palloc(sizeof(bool) * j);
140 
141  /*
142  * Make map to convert item's number to corresponding operand's (the
143  * same, entry's) number. Entry's number is used in check array in
144  * consistent method. We use the same map for each entry.
145  */
146  *extra_data = (Pointer *) palloc(sizeof(Pointer) * j);
147  map_item_operand = (int *) palloc0(sizeof(int) * query->size);
148 
149  /* Now rescan the VAL items and fill in the arrays */
150  j = 0;
151  for (i = 0; i < query->size; i++)
152  {
153  if (item[i].type == QI_VAL)
154  {
155  QueryOperand *val = &item[i].qoperand;
156  text *txt;
157 
158  txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,
159  val->length);
160  entries[j] = PointerGetDatum(txt);
161  partialmatch[j] = val->prefix;
162  (*extra_data)[j] = (Pointer) map_item_operand;
163  map_item_operand[i] = j;
164  j++;
165  }
166  }
167  }
168 
169  PG_FREE_IF_COPY(query, 0);
170 
171  PG_RETURN_POINTER(entries);
172 }
#define GETQUERY(x)
Definition: _int.h:157
signed int int32
Definition: c.h:483
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define GIN_SEARCH_MODE_ALL
Definition: gin.h:36
#define GIN_SEARCH_MODE_DEFAULT
Definition: gin.h:34
int i
Definition: isn.c:73
#define GETOPERAND(x)
Definition: ltree.h:165
void * palloc0(Size size)
Definition: mcxt.c:1257
void * palloc(Size size)
Definition: mcxt.c:1226
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
int32 size
Definition: ts_type.h:221
#define PG_GETARG_TSQUERY(n)
Definition: ts_type.h:266
#define QI_VAL
Definition: ts_type.h:149
bool tsquery_requires_match(QueryItem *curitem)
Definition: tsvector_op.c:2158
QueryOperand qoperand
Definition: ts_type.h:210
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:196
const char * type

References cstring_to_text_with_len(), GETOPERAND, GETQUERY, GIN_SEARCH_MODE_ALL, GIN_SEARCH_MODE_DEFAULT, i, j, palloc(), palloc0(), PG_FREE_IF_COPY, PG_GETARG_POINTER, PG_GETARG_TSQUERY, PG_RETURN_POINTER, PointerGetDatum(), QI_VAL, QueryItem::qoperand, TSQueryData::size, tsquery_requires_match(), type, and val.

Referenced by gin_extract_tsquery_5args(), and gin_extract_tsquery_oldsig().

◆ gin_extract_tsquery_5args()

Datum gin_extract_tsquery_5args ( PG_FUNCTION_ARGS  )

Definition at line 318 of file tsginidx.c.

319 {
320  if (PG_NARGS() < 7) /* should not happen */
321  elog(ERROR, "gin_extract_tsquery requires seven arguments");
322  return gin_extract_tsquery(fcinfo);
323 }
#define ERROR
Definition: elog.h:39
#define PG_NARGS()
Definition: fmgr.h:203
Datum gin_extract_tsquery(PG_FUNCTION_ARGS)
Definition: tsginidx.c:96

References elog(), ERROR, gin_extract_tsquery(), and PG_NARGS.

◆ gin_extract_tsquery_oldsig()

Datum gin_extract_tsquery_oldsig ( PG_FUNCTION_ARGS  )

Definition at line 342 of file tsginidx.c.

343 {
344  return gin_extract_tsquery(fcinfo);
345 }

References gin_extract_tsquery().

◆ gin_extract_tsvector()

Datum gin_extract_tsvector ( PG_FUNCTION_ARGS  )

Definition at line 66 of file tsginidx.c.

67 {
68  TSVector vector = PG_GETARG_TSVECTOR(0);
69  int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
70  Datum *entries = NULL;
71 
72  *nentries = vector->size;
73  if (vector->size > 0)
74  {
75  int i;
76  WordEntry *we = ARRPTR(vector);
77 
78  entries = (Datum *) palloc(sizeof(Datum) * vector->size);
79 
80  for (i = 0; i < vector->size; i++)
81  {
82  text *txt;
83 
84  txt = cstring_to_text_with_len(STRPTR(vector) + we->pos, we->len);
85  entries[i] = PointerGetDatum(txt);
86 
87  we++;
88  }
89  }
90 
91  PG_FREE_IF_COPY(vector, 0);
92  PG_RETURN_POINTER(entries);
93 }
#define ARRPTR(x)
Definition: cube.c:25
#define STRPTR(x)
Definition: hstore.h:76
int32 size
Definition: ts_type.h:93
uint32 pos
Definition: ts_type.h:46
uint32 len
Definition: ts_type.h:45
#define PG_GETARG_TSVECTOR(n)
Definition: ts_type.h:135

References ARRPTR, cstring_to_text_with_len(), i, WordEntry::len, palloc(), PG_FREE_IF_COPY, PG_GETARG_POINTER, PG_GETARG_TSVECTOR, PG_RETURN_POINTER, PointerGetDatum(), WordEntry::pos, TSVectorData::size, and STRPTR.

Referenced by gin_extract_tsvector_2args().

◆ gin_extract_tsvector_2args()

Datum gin_extract_tsvector_2args ( PG_FUNCTION_ARGS  )

Definition at line 306 of file tsginidx.c.

307 {
308  if (PG_NARGS() < 3) /* should not happen */
309  elog(ERROR, "gin_extract_tsvector requires three arguments");
310  return gin_extract_tsvector(fcinfo);
311 }
Datum gin_extract_tsvector(PG_FUNCTION_ARGS)
Definition: tsginidx.c:66

References elog(), ERROR, gin_extract_tsvector(), and PG_NARGS.

◆ gin_tsquery_consistent()

Datum gin_tsquery_consistent ( PG_FUNCTION_ARGS  )

Definition at line 216 of file tsginidx.c.

217 {
218  bool *check = (bool *) PG_GETARG_POINTER(0);
219 
220  /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
221  TSQuery query = PG_GETARG_TSQUERY(2);
222 
223  /* int32 nkeys = PG_GETARG_INT32(3); */
224  Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
225  bool *recheck = (bool *) PG_GETARG_POINTER(5);
226  bool res = false;
227 
228  /* Initially assume query doesn't require recheck */
229  *recheck = false;
230 
231  if (query->size > 0)
232  {
233  GinChkVal gcv;
234 
235  /*
236  * check-parameter array has one entry for each value (operand) in the
237  * query.
238  */
239  gcv.first_item = GETQUERY(query);
240  gcv.check = (GinTernaryValue *) check;
241  gcv.map_item_operand = (int *) (extra_data[0]);
242 
243  switch (TS_execute_ternary(GETQUERY(query),
244  &gcv,
247  {
248  case TS_NO:
249  res = false;
250  break;
251  case TS_YES:
252  res = true;
253  break;
254  case TS_MAYBE:
255  res = true;
256  *recheck = true;
257  break;
258  }
259  }
260 
262 }
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define TS_EXEC_PHRASE_NO_POS
Definition: ts_utils.h:202
@ TS_MAYBE
Definition: ts_utils.h:136
@ TS_NO
Definition: ts_utils.h:134
@ TS_YES
Definition: ts_utils.h:135
static TSTernaryValue checkcondition_gin(void *checkval, QueryOperand *val, ExecPhraseData *data)
Definition: tsginidx.c:185
TSTernaryValue TS_execute_ternary(QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
Definition: tsvector_op.c:1873

References GinChkVal::check, checkcondition_gin(), GinChkVal::first_item, GETQUERY, GinChkVal::map_item_operand, PG_GETARG_POINTER, PG_GETARG_TSQUERY, PG_RETURN_BOOL, res, TSQueryData::size, TS_EXEC_PHRASE_NO_POS, TS_execute_ternary(), TS_MAYBE, TS_NO, and TS_YES.

Referenced by gin_tsquery_consistent_6args(), and gin_tsquery_consistent_oldsig().

◆ gin_tsquery_consistent_6args()

Datum gin_tsquery_consistent_6args ( PG_FUNCTION_ARGS  )

Definition at line 330 of file tsginidx.c.

331 {
332  if (PG_NARGS() < 8) /* should not happen */
333  elog(ERROR, "gin_tsquery_consistent requires eight arguments");
334  return gin_tsquery_consistent(fcinfo);
335 }
Datum gin_tsquery_consistent(PG_FUNCTION_ARGS)
Definition: tsginidx.c:216

References elog(), ERROR, gin_tsquery_consistent(), and PG_NARGS.

◆ gin_tsquery_consistent_oldsig()

Datum gin_tsquery_consistent_oldsig ( PG_FUNCTION_ARGS  )

Definition at line 352 of file tsginidx.c.

353 {
354  return gin_tsquery_consistent(fcinfo);
355 }

References gin_tsquery_consistent().

◆ gin_tsquery_triconsistent()

Datum gin_tsquery_triconsistent ( PG_FUNCTION_ARGS  )

Definition at line 265 of file tsginidx.c.

266 {
268 
269  /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
270  TSQuery query = PG_GETARG_TSQUERY(2);
271 
272  /* int32 nkeys = PG_GETARG_INT32(3); */
273  Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
275 
276  if (query->size > 0)
277  {
278  GinChkVal gcv;
279 
280  /*
281  * check-parameter array has one entry for each value (operand) in the
282  * query.
283  */
284  gcv.first_item = GETQUERY(query);
285  gcv.check = check;
286  gcv.map_item_operand = (int *) (extra_data[0]);
287 
289  &gcv,
292  }
293 
295 }
#define PG_RETURN_GIN_TERNARY_VALUE(x)
Definition: gin.h:79
#define GIN_FALSE
Definition: gin.h:63

References GinChkVal::check, checkcondition_gin(), GinChkVal::first_item, GETQUERY, GIN_FALSE, GinChkVal::map_item_operand, PG_GETARG_POINTER, PG_GETARG_TSQUERY, PG_RETURN_GIN_TERNARY_VALUE, res, TSQueryData::size, TS_EXEC_PHRASE_NO_POS, and TS_execute_ternary().