Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * tsquery.c
4 : : * I/O functions for tsquery
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : *
8 : : *
9 : : * IDENTIFICATION
10 : : * src/backend/utils/adt/tsquery.c
11 : : *
12 : : *-------------------------------------------------------------------------
13 : : */
14 : :
15 : : #include "postgres.h"
16 : :
17 : : #include "libpq/pqformat.h"
18 : : #include "miscadmin.h"
19 : : #include "nodes/miscnodes.h"
20 : : #include "tsearch/ts_locale.h"
21 : : #include "tsearch/ts_type.h"
22 : : #include "tsearch/ts_utils.h"
23 : : #include "utils/builtins.h"
24 : : #include "utils/memutils.h"
25 : : #include "utils/pg_crc.h"
26 : : #include "varatt.h"
27 : :
28 : : /* FTS operator priorities, see ts_type.h */
29 : : const int tsearch_op_priority[OP_COUNT] =
30 : : {
31 : : 4, /* OP_NOT */
32 : : 2, /* OP_AND */
33 : : 1, /* OP_OR */
34 : : 3 /* OP_PHRASE */
35 : : };
36 : :
37 : : /*
38 : : * parser's states
39 : : */
40 : : typedef enum
41 : : {
42 : : WAITOPERAND = 1,
43 : : WAITOPERATOR = 2,
44 : : WAITFIRSTOPERAND = 3,
45 : : } ts_parserstate;
46 : :
47 : : /*
48 : : * token types for parsing
49 : : */
50 : : typedef enum
51 : : {
52 : : PT_END = 0,
53 : : PT_ERR = 1,
54 : : PT_VAL = 2,
55 : : PT_OPR = 3,
56 : : PT_OPEN = 4,
57 : : PT_CLOSE = 5,
58 : : } ts_tokentype;
59 : :
60 : : /*
61 : : * get token from query string
62 : : *
63 : : * All arguments except "state" are output arguments.
64 : : *
65 : : * If return value is PT_OPR, then *operator is filled with an OP_* code
66 : : * and *weight will contain a distance value in case of phrase operator.
67 : : *
68 : : * If return value is PT_VAL, then *lenval, *strval, *weight, and *prefix
69 : : * are filled.
70 : : *
71 : : * If PT_ERR is returned then a soft error has occurred. If state->escontext
72 : : * isn't already filled then this should be reported as a generic parse error.
73 : : */
74 : : typedef ts_tokentype (*ts_tokenizer) (TSQueryParserState state, int8 *operator,
75 : : int *lenval, char **strval,
76 : : int16 *weight, bool *prefix);
77 : :
78 : : struct TSQueryParserStateData
79 : : {
80 : : /* Tokenizer used for parsing tsquery */
81 : : ts_tokenizer gettoken;
82 : :
83 : : /* State of tokenizer function */
84 : : char *buffer; /* entire string we are scanning */
85 : : char *buf; /* current scan point */
86 : : int count; /* nesting count, incremented by (,
87 : : * decremented by ) */
88 : : ts_parserstate state;
89 : :
90 : : /* polish (prefix) notation in list, filled in by push* functions */
91 : : List *polstr;
92 : :
93 : : /*
94 : : * Strings from operands are collected in op. curop is a pointer to the
95 : : * end of used space of op.
96 : : */
97 : : char *op;
98 : : char *curop;
99 : : int lenop; /* allocated size of op */
100 : : int sumlen; /* used size of op */
101 : :
102 : : /* state for value's parser */
103 : : TSVectorParseState valstate;
104 : :
105 : : /* context object for soft errors - must match valstate's escontext */
106 : : Node *escontext;
107 : : };
108 : :
109 : : /*
110 : : * subroutine to parse the modifiers (weight and prefix flag currently)
111 : : * part, like ':AB*' of a query.
112 : : */
113 : : static char *
6677 tgl@sss.pgh.pa.us 114 :CBC 5076 : get_modifiers(char *buf, int16 *weight, bool *prefix)
115 : : {
6946 116 : 5076 : *weight = 0;
6677 117 : 5076 : *prefix = false;
118 : :
6946 119 [ + + ]: 5076 : if (!t_iseq(buf, ':'))
120 : 4641 : return buf;
121 : :
122 : 435 : buf++;
232 tmunro@postgresql.or 123 [ + + + - ]: 1016 : while (*buf && pg_mblen_cstr(buf) == 1)
124 : : {
6946 tgl@sss.pgh.pa.us 125 [ + + + + : 736 : switch (*buf)
+ + ]
126 : : {
127 : 160 : case 'a':
128 : : case 'A':
129 : 160 : *weight |= 1 << 3;
130 : 160 : break;
131 : 50 : case 'b':
132 : : case 'B':
133 : 50 : *weight |= 1 << 2;
134 : 50 : break;
135 : 78 : case 'c':
136 : : case 'C':
137 : 78 : *weight |= 1 << 1;
138 : 78 : break;
139 : 81 : case 'd':
140 : : case 'D':
141 : 81 : *weight |= 1;
142 : 81 : break;
6677 143 : 212 : case '*':
144 : 212 : *prefix = true;
145 : 212 : break;
6946 146 : 155 : default:
147 : 155 : return buf;
148 : : }
149 : 581 : buf++;
150 : : }
151 : :
152 : 280 : return buf;
153 : : }
154 : :
155 : : /*
156 : : * Parse phrase operator. The operator
157 : : * may take the following forms:
158 : : *
159 : : * a <N> b (distance is exactly N lexemes)
160 : : * a <-> b (default distance = 1)
161 : : *
162 : : * The buffer should begin with '<' char
163 : : */
164 : : static bool
3066 teodor@sigaev.ru 165 : 6469 : parse_phrase_operator(TSQueryParserState pstate, int16 *distance)
166 : : {
167 : : enum
168 : : {
169 : : PHRASE_OPEN = 0,
170 : : PHRASE_DIST,
171 : : PHRASE_CLOSE,
172 : : PHRASE_FINISH
3731 rhaas@postgresql.org 173 : 6469 : } state = PHRASE_OPEN;
3066 teodor@sigaev.ru 174 : 6469 : char *ptr = pstate->buf;
175 : : char *endptr;
3349 tgl@sss.pgh.pa.us 176 : 6469 : long l = 1; /* default distance */
177 : :
3794 teodor@sigaev.ru 178 [ + + ]: 16716 : while (*ptr)
179 : : {
3731 rhaas@postgresql.org 180 [ + + + + : 7939 : switch (state)
- ]
181 : : {
3794 teodor@sigaev.ru 182 : 4161 : case PHRASE_OPEN:
3066 183 [ + + ]: 4161 : if (t_iseq(ptr, '<'))
184 : : {
185 : 1262 : state = PHRASE_DIST;
186 : 1262 : ptr++;
187 : : }
188 : : else
189 : 2899 : return false;
3794 190 : 1262 : break;
191 : :
192 : 1262 : case PHRASE_DIST:
193 [ + + ]: 1262 : if (t_iseq(ptr, '-'))
194 : : {
195 : 1054 : state = PHRASE_CLOSE;
196 : 1054 : ptr++;
3066 197 : 1054 : continue;
198 : : }
199 : :
618 peter@eisentraut.org 200 [ - + ]: 208 : if (!isdigit((unsigned char) *ptr))
3066 teodor@sigaev.ru 201 :UBC 0 : return false;
202 : :
3349 tgl@sss.pgh.pa.us 203 :CBC 208 : errno = 0;
3794 teodor@sigaev.ru 204 : 208 : l = strtol(ptr, &endptr, 10);
205 [ - + ]: 208 : if (ptr == endptr)
3066 teodor@sigaev.ru 206 :UBC 0 : return false;
3349 tgl@sss.pgh.pa.us 207 [ + - + - :CBC 208 : else if (errno == ERANGE || l < 0 || l > MAXENTRYPOS)
+ + ]
1339 208 [ + - ]: 4 : ereturn(pstate->escontext, false,
209 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
210 : : errmsg("distance in phrase operator must be an integer value between zero and %d inclusive",
211 : : MAXENTRYPOS)));
212 : : else
213 : : {
3794 teodor@sigaev.ru 214 : 204 : state = PHRASE_CLOSE;
215 : 204 : ptr = endptr;
216 : : }
217 : 204 : break;
218 : :
219 : 1258 : case PHRASE_CLOSE:
220 [ + - ]: 1258 : if (t_iseq(ptr, '>'))
221 : : {
222 : 1258 : state = PHRASE_FINISH;
223 : 1258 : ptr++;
224 : : }
225 : : else
3066 teodor@sigaev.ru 226 :UBC 0 : return false;
3794 teodor@sigaev.ru 227 :CBC 1258 : break;
228 : :
229 : 1258 : case PHRASE_FINISH:
230 : 1258 : *distance = (int16) l;
3066 231 : 1258 : pstate->buf = ptr;
232 : 1258 : return true;
233 : : }
234 : : }
235 : :
236 : 2308 : return false;
237 : : }
238 : :
239 : : /*
240 : : * Parse OR operator used in websearch_to_tsquery(), returns true if we
241 : : * believe that "OR" literal could be an operator OR
242 : : */
243 : : static bool
244 : 1165 : parse_or_operator(TSQueryParserState pstate)
245 : : {
3045 tgl@sss.pgh.pa.us 246 : 1165 : char *ptr = pstate->buf;
247 : :
248 : : /* it should begin with "OR" literal */
3066 teodor@sigaev.ru 249 [ + + ]: 1165 : if (pg_strncasecmp(ptr, "or", 2) != 0)
250 : 1040 : return false;
251 : :
252 : 125 : ptr += 2;
253 : :
254 : : /*
255 : : * it shouldn't be a part of any word but somewhere later it should be
256 : : * some operand
257 : : */
3045 tgl@sss.pgh.pa.us 258 [ + + ]: 125 : if (*ptr == '\0') /* no operand */
3066 teodor@sigaev.ru 259 : 5 : return false;
260 : :
261 : : /* it shouldn't be a part of any word */
232 tmunro@postgresql.or 262 [ + + + + : 120 : if (t_iseq(ptr, '-') || t_iseq(ptr, '_') || t_isalnum_cstr(ptr))
+ + ]
3066 teodor@sigaev.ru 263 : 20 : return false;
264 : :
265 : : for (;;)
266 : : {
232 tmunro@postgresql.or 267 : 100 : ptr += pg_mblen_cstr(ptr);
268 : :
3045 tgl@sss.pgh.pa.us 269 [ + + ]: 100 : if (*ptr == '\0') /* got end of string without operand */
3066 teodor@sigaev.ru 270 : 10 : return false;
271 : :
272 : : /*
273 : : * Suppose, we found an operand, but could be a not correct operand.
274 : : * So we still treat OR literal as operation with possibly incorrect
275 : : * operand and will not search it as lexeme
276 : : */
618 peter@eisentraut.org 277 [ + - ]: 90 : if (!isspace((unsigned char) *ptr))
3066 teodor@sigaev.ru 278 : 90 : break;
279 : : }
280 : :
281 : 90 : pstate->buf += 2;
282 : 90 : return true;
283 : : }
284 : :
285 : : static ts_tokentype
286 : 12343 : gettoken_query_standard(TSQueryParserState state, int8 *operator,
287 : : int *lenval, char **strval,
288 : : int16 *weight, bool *prefix)
289 : : {
6677 tgl@sss.pgh.pa.us 290 : 12343 : *weight = 0;
291 : 12343 : *prefix = false;
292 : :
293 : : while (true)
294 : : {
6946 295 [ + + - ]: 16556 : switch (state->state)
296 : : {
297 : 8589 : case WAITFIRSTOPERAND:
298 : : case WAITOPERAND:
299 [ + + ]: 8589 : if (t_iseq(state->buf, '!'))
300 : : {
3066 teodor@sigaev.ru 301 : 627 : state->buf++;
6946 tgl@sss.pgh.pa.us 302 : 627 : state->state = WAITOPERAND;
3066 teodor@sigaev.ru 303 : 627 : *operator = OP_NOT;
6929 304 : 627 : return PT_OPR;
305 : : }
6946 tgl@sss.pgh.pa.us 306 [ + + ]: 7962 : else if (t_iseq(state->buf, '('))
307 : : {
3066 teodor@sigaev.ru 308 : 773 : state->buf++;
6946 tgl@sss.pgh.pa.us 309 : 773 : state->state = WAITOPERAND;
3066 teodor@sigaev.ru 310 : 773 : state->count++;
6929 311 : 773 : return PT_OPEN;
312 : : }
6946 tgl@sss.pgh.pa.us 313 [ - + ]: 7189 : else if (t_iseq(state->buf, ':'))
314 : : {
315 : : /* generic syntax error message is fine */
1339 tgl@sss.pgh.pa.us 316 :UBC 0 : return PT_ERR;
317 : : }
618 peter@eisentraut.org 318 [ + + ]:CBC 7189 : else if (!isspace((unsigned char) *state->buf))
319 : : {
320 : : /*
321 : : * We rely on the tsvector parser to parse the value for
322 : : * us
323 : : */
6929 teodor@sigaev.ru 324 : 5094 : reset_tsvector_parser(state->valstate, state->buf);
3066 325 [ + + ]: 5094 : if (gettoken_tsvector(state->valstate, strval, lenval,
326 : : NULL, NULL, &state->buf))
327 : : {
6677 tgl@sss.pgh.pa.us 328 : 5076 : state->buf = get_modifiers(state->buf, weight, prefix);
6946 329 : 5076 : state->state = WAITOPERATOR;
6929 teodor@sigaev.ru 330 : 5076 : return PT_VAL;
331 : : }
1339 tgl@sss.pgh.pa.us 332 [ - + - - : 18 : else if (SOFT_ERROR_OCCURRED(state->escontext))
- - ]
333 : : {
334 : : /* gettoken_tsvector reported a soft error */
1339 tgl@sss.pgh.pa.us 335 :UBC 0 : return PT_ERR;
336 : : }
6946 tgl@sss.pgh.pa.us 337 [ + - ]:CBC 18 : else if (state->state == WAITFIRSTOPERAND)
338 : : {
6929 teodor@sigaev.ru 339 : 18 : return PT_END;
340 : : }
341 : : else
1339 tgl@sss.pgh.pa.us 342 [ # # ]:UBC 0 : ereturn(state->escontext, PT_ERR,
343 : : (errcode(ERRCODE_SYNTAX_ERROR),
344 : : errmsg("no operand in tsquery: \"%s\"",
345 : : state->buffer)));
346 : : }
6946 tgl@sss.pgh.pa.us 347 :CBC 2095 : break;
348 : :
349 : 7967 : case WAITOPERATOR:
6929 teodor@sigaev.ru 350 [ + + ]: 7967 : if (t_iseq(state->buf, '&'))
351 : : {
3066 352 : 942 : state->buf++;
6929 353 : 942 : state->state = WAITOPERAND;
354 : 942 : *operator = OP_AND;
355 : 942 : return PT_OPR;
356 : : }
3794 357 [ + + ]: 7025 : else if (t_iseq(state->buf, '|'))
358 : : {
3066 359 : 556 : state->buf++;
6946 tgl@sss.pgh.pa.us 360 : 556 : state->state = WAITOPERAND;
6929 teodor@sigaev.ru 361 : 556 : *operator = OP_OR;
362 : 556 : return PT_OPR;
363 : : }
3066 364 [ + + ]: 6469 : else if (parse_phrase_operator(state, weight))
365 : : {
366 : : /* weight var is used as storage for distance */
3794 367 : 1258 : state->state = WAITOPERAND;
368 : 1258 : *operator = OP_PHRASE;
369 : 1258 : return PT_OPR;
370 : : }
1339 tgl@sss.pgh.pa.us 371 [ + + + - : 5211 : else if (SOFT_ERROR_OCCURRED(state->escontext))
+ + ]
372 : : {
373 : : /* parse_phrase_operator reported a soft error */
374 : 4 : return PT_ERR;
375 : : }
6946 376 [ + + ]: 5207 : else if (t_iseq(state->buf, ')'))
377 : : {
3066 teodor@sigaev.ru 378 : 773 : state->buf++;
6946 tgl@sss.pgh.pa.us 379 : 773 : state->count--;
6929 teodor@sigaev.ru 380 [ - + ]: 773 : return (state->count < 0) ? PT_ERR : PT_CLOSE;
381 : : }
3066 382 [ + + ]: 4434 : else if (*state->buf == '\0')
383 : : {
6929 384 : 2308 : return (state->count) ? PT_ERR : PT_END;
385 : : }
618 peter@eisentraut.org 386 [ + + ]: 2126 : else if (!isspace((unsigned char) *state->buf))
387 : : {
6929 teodor@sigaev.ru 388 : 8 : return PT_ERR;
389 : : }
3066 390 : 2118 : break;
391 : : }
392 : :
232 tmunro@postgresql.or 393 : 4213 : state->buf += pg_mblen_cstr(state->buf);
394 : : }
395 : : }
396 : :
397 : : static ts_tokentype
3066 teodor@sigaev.ru 398 : 1877 : gettoken_query_websearch(TSQueryParserState state, int8 *operator,
399 : : int *lenval, char **strval,
400 : : int16 *weight, bool *prefix)
401 : : {
402 : 1877 : *weight = 0;
403 : 1877 : *prefix = false;
404 : :
405 : : while (true)
406 : : {
407 [ + + - ]: 2622 : switch (state->state)
408 : : {
409 : 1116 : case WAITFIRSTOPERAND:
410 : : case WAITOPERAND:
411 [ + + ]: 1116 : if (t_iseq(state->buf, '-'))
412 : : {
413 : 55 : state->buf++;
414 : 55 : state->state = WAITOPERAND;
415 : :
416 : 55 : *operator = OP_NOT;
417 : 55 : return PT_OPR;
418 : : }
419 [ + + ]: 1061 : else if (t_iseq(state->buf, '"'))
420 : : {
421 : : /* Everything in quotes is processed as a single token */
422 : :
423 : : /* skip opening quote */
424 : 160 : state->buf++;
1942 akorotkov@postgresql 425 : 160 : *strval = state->buf;
426 : :
427 : : /* iterate to the closing quote or end of the string */
428 [ + + + + ]: 1450 : while (*state->buf != '\0' && !t_iseq(state->buf, '"'))
429 : 1290 : state->buf++;
430 : 160 : *lenval = state->buf - *strval;
431 : :
432 : : /* skip closing quote if not end of the string */
433 [ + + ]: 160 : if (*state->buf != '\0')
434 : 140 : state->buf++;
435 : :
436 : 160 : state->state = WAITOPERATOR;
437 : 160 : state->count++;
438 : 160 : return PT_VAL;
439 : : }
3066 teodor@sigaev.ru 440 [ + + + + : 901 : else if (ISOPERATOR(state->buf))
+ + + + +
+ + + ]
441 : : {
442 : : /* ignore, else gettoken_tsvector() will raise an error */
443 : 85 : state->buf++;
444 : 85 : state->state = WAITOPERAND;
445 : 85 : continue;
446 : : }
618 peter@eisentraut.org 447 [ + + ]: 816 : else if (!isspace((unsigned char) *state->buf))
448 : : {
449 : : /*
450 : : * We rely on the tsvector parser to parse the value for
451 : : * us
452 : : */
3066 teodor@sigaev.ru 453 : 751 : reset_tsvector_parser(state->valstate, state->buf);
454 [ + - ]: 751 : if (gettoken_tsvector(state->valstate, strval, lenval,
455 : : NULL, NULL, &state->buf))
456 : : {
457 : 751 : state->state = WAITOPERATOR;
458 : 751 : return PT_VAL;
459 : : }
1339 tgl@sss.pgh.pa.us 460 [ # # # # :UBC 0 : else if (SOFT_ERROR_OCCURRED(state->escontext))
# # ]
461 : : {
462 : : /* gettoken_tsvector reported a soft error */
463 : 0 : return PT_ERR;
464 : : }
3066 teodor@sigaev.ru 465 [ # # ]: 0 : else if (state->state == WAITFIRSTOPERAND)
466 : : {
467 : 0 : return PT_END;
468 : : }
469 : : else
470 : : {
471 : : /* finally, we have to provide an operand */
472 : 0 : pushStop(state);
473 : 0 : return PT_END;
474 : : }
475 : : }
6946 tgl@sss.pgh.pa.us 476 :CBC 65 : break;
477 : :
3066 teodor@sigaev.ru 478 : 1506 : case WAITOPERATOR:
805 tgl@sss.pgh.pa.us 479 [ + + ]: 1506 : if (*state->buf == '\0')
480 : : {
481 : 341 : return PT_END;
482 : : }
3066 teodor@sigaev.ru 483 [ + + ]: 1165 : else if (parse_or_operator(state))
484 : : {
485 : 90 : state->state = WAITOPERAND;
486 : 90 : *operator = OP_OR;
487 : 90 : return PT_OPR;
488 : : }
805 tgl@sss.pgh.pa.us 489 [ + + + + : 1075 : else if (ISOPERATOR(state->buf))
+ + + + +
+ + + ]
490 : : {
491 : : /* ignore other operators in this state too */
492 : 95 : state->buf++;
493 : 95 : continue;
494 : : }
618 peter@eisentraut.org 495 [ + + ]: 980 : else if (!isspace((unsigned char) *state->buf))
496 : : {
497 : : /* insert implicit AND between operands */
3066 teodor@sigaev.ru 498 : 480 : state->state = WAITOPERAND;
805 tgl@sss.pgh.pa.us 499 : 480 : *operator = OP_AND;
3066 teodor@sigaev.ru 500 : 480 : return PT_OPR;
501 : : }
6946 tgl@sss.pgh.pa.us 502 : 500 : break;
503 : : }
504 : :
232 tmunro@postgresql.or 505 : 565 : state->buf += pg_mblen_cstr(state->buf);
506 : : }
507 : : }
508 : :
509 : : static ts_tokentype
3066 teodor@sigaev.ru 510 : 176 : gettoken_query_plain(TSQueryParserState state, int8 *operator,
511 : : int *lenval, char **strval,
512 : : int16 *weight, bool *prefix)
513 : : {
514 : 176 : *weight = 0;
515 : 176 : *prefix = false;
516 : :
517 [ + + ]: 176 : if (*state->buf == '\0')
518 : 88 : return PT_END;
519 : :
520 : 88 : *strval = state->buf;
521 : 88 : *lenval = strlen(state->buf);
522 : 88 : state->buf += *lenval;
523 : 88 : state->count++;
524 : 88 : return PT_VAL;
525 : : }
526 : :
527 : : /*
528 : : * Push an operator to state->polstr
529 : : */
530 : : void
3794 531 : 4560 : pushOperator(TSQueryParserState state, int8 oper, int16 distance)
532 : : {
533 : : QueryOperator *tmp;
534 : :
535 [ + + + + : 4560 : Assert(oper == OP_NOT || oper == OP_AND || oper == OP_OR || oper == OP_PHRASE);
+ + - + ]
536 : :
260 michael@paquier.xyz 537 : 4560 : tmp = palloc0_object(QueryOperator);
6929 teodor@sigaev.ru 538 : 4560 : tmp->type = QI_OPR;
539 : 4560 : tmp->oper = oper;
3794 540 [ + + ]: 4560 : tmp->distance = (oper == OP_PHRASE) ? distance : 0;
541 : : /* left is filled in later with findoprnd */
542 : :
6929 543 : 4560 : state->polstr = lcons(tmp, state->polstr);
544 : 4560 : }
545 : :
546 : : static void
6677 tgl@sss.pgh.pa.us 547 : 6077 : pushValue_internal(TSQueryParserState state, pg_crc32 valcrc, int distance, int lenval, int weight, bool prefix)
548 : : {
549 : : QueryOperand *tmp;
550 : :
14 551 [ - + ]: 6077 : if (distance > MAXSTRPOS)
1339 tgl@sss.pgh.pa.us 552 [ # # ]:UBC 0 : ereturn(state->escontext,,
553 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
554 : : errmsg("value is too big in tsquery: \"%s\"",
555 : : state->buffer)));
14 tgl@sss.pgh.pa.us 556 [ - + ]:CBC 6077 : if (lenval > MAXSTRLEN)
1339 tgl@sss.pgh.pa.us 557 [ # # ]:UBC 0 : ereturn(state->escontext,,
558 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
559 : : errmsg("operand is too long in tsquery: \"%s\"",
560 : : state->buffer)));
561 : :
260 michael@paquier.xyz 562 :CBC 6077 : tmp = palloc0_object(QueryOperand);
6929 teodor@sigaev.ru 563 : 6077 : tmp->type = QI_VAL;
564 : 6077 : tmp->weight = weight;
6677 tgl@sss.pgh.pa.us 565 : 6077 : tmp->prefix = prefix;
6929 teodor@sigaev.ru 566 : 6077 : tmp->valcrc = (int32) valcrc;
6946 tgl@sss.pgh.pa.us 567 : 6077 : tmp->length = lenval;
6929 teodor@sigaev.ru 568 : 6077 : tmp->distance = distance;
569 : :
570 : 6077 : state->polstr = lcons(tmp, state->polstr);
571 : : }
572 : :
573 : : /*
574 : : * Push an operand to state->polstr.
575 : : *
576 : : * strval must point to a string equal to state->curop. lenval is the length
577 : : * of the string.
578 : : */
579 : : void
5176 peter_e@gmx.net 580 : 6077 : pushValue(TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
581 : : {
582 : : pg_crc32 valcrc;
583 : :
14 tgl@sss.pgh.pa.us 584 [ - + ]: 6077 : if (lenval > MAXSTRLEN)
1339 tgl@sss.pgh.pa.us 585 [ # # ]:UBC 0 : ereturn(state->escontext,,
586 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
587 : : errmsg("word is too long in tsquery: \"%s\"",
588 : : state->buffer)));
589 : :
4314 heikki.linnakangas@i 590 :CBC 6077 : INIT_LEGACY_CRC32(valcrc);
591 [ + + ]: 21903 : COMP_LEGACY_CRC32(valcrc, strval, lenval);
592 : 6077 : FIN_LEGACY_CRC32(valcrc);
6677 tgl@sss.pgh.pa.us 593 : 6077 : pushValue_internal(state, valcrc, state->curop - state->op, lenval, weight, prefix);
594 : :
595 : : /* append the value string to state.op, enlarging buffer if needed first */
6946 596 [ - + ]: 6077 : while (state->curop - state->op + lenval + 1 >= state->lenop)
597 : : {
6860 bruce@momjian.us 598 :UBC 0 : int used = state->curop - state->op;
599 : :
6946 tgl@sss.pgh.pa.us 600 : 0 : state->lenop *= 2;
1297 peter@eisentraut.org 601 : 0 : state->op = (char *) repalloc(state->op, state->lenop);
6929 teodor@sigaev.ru 602 : 0 : state->curop = state->op + used;
603 : : }
1297 peter@eisentraut.org 604 :CBC 6077 : memcpy(state->curop, strval, lenval);
6946 tgl@sss.pgh.pa.us 605 : 6077 : state->curop += lenval;
606 : 6077 : *(state->curop) = '\0';
607 : 6077 : state->curop++;
608 : 6077 : state->sumlen += lenval + 1 /* \0 */ ;
609 : : }
610 : :
611 : :
612 : : /*
613 : : * Push a stopword placeholder to state->polstr
614 : : */
615 : : void
6929 teodor@sigaev.ru 616 : 550 : pushStop(TSQueryParserState state)
617 : : {
618 : : QueryOperand *tmp;
619 : :
260 michael@paquier.xyz 620 : 550 : tmp = palloc0_object(QueryOperand);
6929 teodor@sigaev.ru 621 : 550 : tmp->type = QI_VALSTOP;
622 : :
623 : 550 : state->polstr = lcons(tmp, state->polstr);
624 : 550 : }
625 : :
626 : :
627 : : #define STACKDEPTH 32
628 : :
629 : : typedef struct OperatorElement
630 : : {
631 : : int8 op;
632 : : int16 distance;
633 : : } OperatorElement;
634 : :
635 : : static void
3713 636 : 4008 : pushOpStack(OperatorElement *stack, int *lenstack, int8 op, int16 distance)
637 : : {
3664 tgl@sss.pgh.pa.us 638 [ - + ]: 4008 : if (*lenstack == STACKDEPTH) /* internal error */
3713 teodor@sigaev.ru 639 [ # # ]:UBC 0 : elog(ERROR, "tsquery stack too small");
640 : :
3713 teodor@sigaev.ru 641 :CBC 4008 : stack[*lenstack].op = op;
642 : 4008 : stack[*lenstack].distance = distance;
643 : :
644 : 4008 : (*lenstack)++;
645 : 4008 : }
646 : :
647 : : static void
648 : 7536 : cleanOpStack(TSQueryParserState state,
649 : : OperatorElement *stack, int *lenstack, int8 op)
650 : : {
3664 tgl@sss.pgh.pa.us 651 : 7536 : int opPriority = OP_PRIORITY(op);
652 : :
653 [ + + ]: 11544 : while (*lenstack)
654 : : {
655 : : /* NOT is right associative unlike to others */
3695 teodor@sigaev.ru 656 [ + + + + : 4351 : if ((op != OP_NOT && opPriority > OP_PRIORITY(stack[*lenstack - 1].op)) ||
+ + ]
3354 tgl@sss.pgh.pa.us 657 [ - + ]: 228 : (op == OP_NOT && opPriority >= OP_PRIORITY(stack[*lenstack - 1].op)))
658 : : break;
659 : :
3713 teodor@sigaev.ru 660 : 4008 : (*lenstack)--;
661 : 4008 : pushOperator(state, stack[*lenstack].op,
3664 tgl@sss.pgh.pa.us 662 : 4008 : stack[*lenstack].distance);
663 : : }
3713 teodor@sigaev.ru 664 : 7536 : }
665 : :
666 : : /*
667 : : * Make polish (prefix) notation of query.
668 : : *
669 : : * See parse_tsquery for explanation of pushval.
670 : : */
671 : : static void
6860 bruce@momjian.us 672 : 3540 : makepol(TSQueryParserState state,
673 : : PushFunction pushval,
674 : : void *opaque)
675 : : {
3731 rhaas@postgresql.org 676 : 3540 : int8 operator = 0;
677 : : ts_tokentype type;
678 : 3540 : int lenval = 0;
679 : 3540 : char *strval = NULL;
680 : : OperatorElement opstack[STACKDEPTH];
681 : 3540 : int lenstack = 0;
682 : 3540 : int16 weight = 0;
683 : : bool prefix;
684 : :
685 : : /* since this function recurses, it could be driven to stack overflow */
6936 tgl@sss.pgh.pa.us 686 : 3540 : check_stack_depth();
687 : :
3066 teodor@sigaev.ru 688 : 14396 : while ((type = state->gettoken(state, &operator,
689 : : &lenval, &strval,
690 [ + + ]: 14396 : &weight, &prefix)) != PT_END)
691 : : {
6946 tgl@sss.pgh.pa.us 692 [ + + + + : 11641 : switch (type)
+ ]
693 : : {
6929 teodor@sigaev.ru 694 : 6075 : case PT_VAL:
6677 tgl@sss.pgh.pa.us 695 : 6075 : pushval(opaque, state, strval, lenval, weight, prefix);
6946 696 : 6075 : break;
6929 teodor@sigaev.ru 697 : 4008 : case PT_OPR:
3713 698 : 4008 : cleanOpStack(state, opstack, &lenstack, operator);
699 : 4008 : pushOpStack(opstack, &lenstack, operator, weight);
6946 tgl@sss.pgh.pa.us 700 : 4008 : break;
6929 teodor@sigaev.ru 701 : 773 : case PT_OPEN:
702 : 773 : makepol(state, pushval, opaque);
6946 tgl@sss.pgh.pa.us 703 : 773 : break;
6929 teodor@sigaev.ru 704 : 773 : case PT_CLOSE:
3664 tgl@sss.pgh.pa.us 705 : 773 : cleanOpStack(state, opstack, &lenstack, OP_OR /* lowest */ );
6929 teodor@sigaev.ru 706 : 785 : return;
707 : 12 : case PT_ERR:
708 : : default:
709 : : /* don't overwrite a soft error saved by gettoken function */
1339 tgl@sss.pgh.pa.us 710 [ + - + - : 12 : if (!SOFT_ERROR_OCCURRED(state->escontext))
+ + ]
711 [ + + ]: 8 : errsave(state->escontext,
712 : : (errcode(ERRCODE_SYNTAX_ERROR),
713 : : errmsg("syntax error in tsquery: \"%s\"",
714 : : state->buffer)));
715 : 12 : return;
716 : : }
717 : : /* detect soft error in pushval or recursion */
718 [ + + + - : 10856 : if (SOFT_ERROR_OCCURRED(state->escontext))
- + ]
1339 tgl@sss.pgh.pa.us 719 :UBC 0 : return;
720 : : }
721 : :
3664 tgl@sss.pgh.pa.us 722 :CBC 2755 : cleanOpStack(state, opstack, &lenstack, OP_OR /* lowest */ );
723 : : }
724 : :
725 : : static void
3794 teodor@sigaev.ru 726 : 11175 : findoprnd_recurse(QueryItem *ptr, uint32 *pos, int nnodes, bool *needcleanup)
727 : : {
728 : : /* since this function recurses, it could be driven to stack overflow. */
6929 729 : 11175 : check_stack_depth();
730 : :
731 [ - + ]: 11175 : if (*pos >= nnodes)
6847 tgl@sss.pgh.pa.us 732 [ # # ]:UBC 0 : elog(ERROR, "malformed tsquery: operand not found");
733 : :
3794 teodor@sigaev.ru 734 [ + + ]:CBC 11175 : if (ptr[*pos].type == QI_VAL)
735 : : {
736 : 6065 : (*pos)++;
737 : : }
738 [ + + ]: 5110 : else if (ptr[*pos].type == QI_VALSTOP)
739 : : {
3731 rhaas@postgresql.org 740 : 550 : *needcleanup = true; /* we'll have to remove stop words */
6946 tgl@sss.pgh.pa.us 741 : 550 : (*pos)++;
742 : : }
743 : : else
744 : : {
6929 teodor@sigaev.ru 745 [ - + ]: 4560 : Assert(ptr[*pos].type == QI_OPR);
746 : :
6251 peter_e@gmx.net 747 [ + + ]: 4560 : if (ptr[*pos].qoperator.oper == OP_NOT)
748 : : {
3354 tgl@sss.pgh.pa.us 749 : 682 : ptr[*pos].qoperator.left = 1; /* fixed offset */
6929 teodor@sigaev.ru 750 : 682 : (*pos)++;
751 : :
752 : : /* process the only argument */
3794 753 : 682 : findoprnd_recurse(ptr, pos, nnodes, needcleanup);
754 : : }
755 : : else
756 : : {
3731 rhaas@postgresql.org 757 : 3878 : QueryOperator *curitem = &ptr[*pos].qoperator;
3354 tgl@sss.pgh.pa.us 758 : 3878 : int tmp = *pos; /* save current position */
759 : :
3794 teodor@sigaev.ru 760 [ + + + + : 3878 : Assert(curitem->oper == OP_AND ||
- + ]
761 : : curitem->oper == OP_OR ||
762 : : curitem->oper == OP_PHRASE);
763 : :
6929 764 : 3878 : (*pos)++;
765 : :
766 : : /* process RIGHT argument */
3794 767 : 3878 : findoprnd_recurse(ptr, pos, nnodes, needcleanup);
768 : :
769 : 3878 : curitem->left = *pos - tmp; /* set LEFT arg's offset */
770 : :
771 : : /* process LEFT argument */
772 : 3878 : findoprnd_recurse(ptr, pos, nnodes, needcleanup);
773 : : }
774 : : }
6946 tgl@sss.pgh.pa.us 775 : 11175 : }
776 : :
777 : :
778 : : /*
779 : : * Fill in the left-fields previously left unfilled.
780 : : * The input QueryItems must be in polish (prefix) notation.
781 : : * Also, set *needcleanup to true if there are any QI_VALSTOP nodes.
782 : : */
783 : : static void
3794 teodor@sigaev.ru 784 : 2737 : findoprnd(QueryItem *ptr, int size, bool *needcleanup)
785 : : {
786 : : uint32 pos;
787 : :
788 : 2737 : *needcleanup = false;
6929 789 : 2737 : pos = 0;
3794 790 : 2737 : findoprnd_recurse(ptr, &pos, size, needcleanup);
791 : :
6929 792 [ - + ]: 2737 : if (pos != size)
6847 tgl@sss.pgh.pa.us 793 [ # # ]:UBC 0 : elog(ERROR, "malformed tsquery: extra nodes");
6929 teodor@sigaev.ru 794 :CBC 2737 : }
795 : :
796 : :
797 : : /*
798 : : * Parse the tsquery stored in "buf".
799 : : *
800 : : * Each value (operand) in the query is passed to pushval. pushval can
801 : : * transform the simple value to an arbitrarily complex expression using
802 : : * pushValue and pushOperator. It must push a single value with pushValue,
803 : : * a complete expression with all operands, or a stopword placeholder
804 : : * with pushStop, otherwise the prefix notation representation will be broken,
805 : : * having an operator with no operand.
806 : : *
807 : : * opaque is passed on to pushval as is, pushval can use it to store its
808 : : * private state.
809 : : *
810 : : * The pushval function can record soft errors via escontext.
811 : : * Callers must check SOFT_ERROR_OCCURRED to detect that.
812 : : *
813 : : * A bitmask of flags (see ts_utils.h) and an error context object
814 : : * can be provided as well. If a soft error occurs, NULL is returned.
815 : : */
816 : : TSQuery
6860 bruce@momjian.us 817 : 2767 : parse_tsquery(char *buf,
818 : : PushFunction pushval,
819 : : void *opaque,
820 : : int flags,
821 : : Node *escontext)
822 : : {
823 : : struct TSQueryParserStateData state;
824 : : int i;
825 : : TSQuery query;
826 : : int commonlen;
827 : : QueryItem *ptr;
828 : : ListCell *cell;
829 : : bool noisy;
830 : : bool needcleanup;
3066 teodor@sigaev.ru 831 : 2767 : int tsv_flags = P_TSV_OPR_IS_DELIM | P_TSV_IS_TSQUERY;
832 : :
833 : : /* plain should not be used with web */
834 [ - + ]: 2767 : Assert((flags & (P_TSQ_PLAIN | P_TSQ_WEB)) != (P_TSQ_PLAIN | P_TSQ_WEB));
835 : :
836 : : /* select suitable tokenizer */
837 [ + + ]: 2767 : if (flags & P_TSQ_PLAIN)
838 : 88 : state.gettoken = gettoken_query_plain;
839 [ + + ]: 2679 : else if (flags & P_TSQ_WEB)
840 : : {
841 : 341 : state.gettoken = gettoken_query_websearch;
842 : 341 : tsv_flags |= P_TSV_IS_WEB;
843 : : }
844 : : else
845 : 2338 : state.gettoken = gettoken_query_standard;
846 : :
847 : : /* emit nuisance NOTICEs only if not doing soft errors */
1339 tgl@sss.pgh.pa.us 848 [ + + - + ]: 2767 : noisy = !(escontext && IsA(escontext, ErrorSaveContext));
849 : :
850 : : /* init state */
6946 851 : 2767 : state.buffer = buf;
852 : 2767 : state.buf = buf;
853 : 2767 : state.count = 0;
3066 teodor@sigaev.ru 854 : 2767 : state.state = WAITFIRSTOPERAND;
6929 855 : 2767 : state.polstr = NIL;
1339 tgl@sss.pgh.pa.us 856 : 2767 : state.escontext = escontext;
857 : :
858 : : /* init value parser's state */
859 : 2767 : state.valstate = init_tsvector_parser(state.buffer, tsv_flags, escontext);
860 : :
861 : : /* init list of operand */
6946 862 : 2767 : state.sumlen = 0;
863 : 2767 : state.lenop = 64;
864 : 2767 : state.curop = state.op = (char *) palloc(state.lenop);
865 : 2767 : *(state.curop) = '\0';
866 : :
867 : : /* parse query & make polish notation (postfix, but in reverse order) */
6929 teodor@sigaev.ru 868 : 2767 : makepol(&state, pushval, opaque);
869 : :
870 : 2767 : close_tsvector_parser(state.valstate);
871 : :
1339 tgl@sss.pgh.pa.us 872 [ + + + - : 2767 : if (SOFT_ERROR_OCCURRED(escontext))
+ + ]
873 : 12 : return NULL;
874 : :
1471 875 [ + + ]: 2755 : if (state.polstr == NIL)
876 : : {
1339 877 [ + - ]: 18 : if (noisy)
878 [ + + ]: 18 : ereport(NOTICE,
879 : : (errmsg("text-search query doesn't contain lexemes: \"%s\"",
880 : : state.buffer)));
6946 881 : 18 : query = (TSQuery) palloc(HDRSIZETQ);
882 : 18 : SET_VARSIZE(query, HDRSIZETQ);
883 : 18 : query->size = 0;
884 : 18 : return query;
885 : : }
886 : :
4574 noah@leadboat.com 887 [ + - - + ]: 2737 : if (TSQUERY_TOO_BIG(list_length(state.polstr), state.sumlen))
1339 tgl@sss.pgh.pa.us 888 [ # # ]:UBC 0 : ereturn(escontext, NULL,
889 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
890 : : errmsg("tsquery is too large")));
6929 teodor@sigaev.ru 891 :CBC 2737 : commonlen = COMPUTESIZE(list_length(state.polstr), state.sumlen);
892 : :
893 : : /* Pack the QueryItems in the final TSQuery struct to return to caller */
894 : 2737 : query = (TSQuery) palloc0(commonlen);
6946 tgl@sss.pgh.pa.us 895 : 2737 : SET_VARSIZE(query, commonlen);
6929 teodor@sigaev.ru 896 : 2737 : query->size = list_length(state.polstr);
6946 tgl@sss.pgh.pa.us 897 : 2737 : ptr = GETQUERY(query);
898 : :
899 : : /* Copy QueryItems to TSQuery */
6929 teodor@sigaev.ru 900 : 2737 : i = 0;
901 [ + - + + : 13912 : foreach(cell, state.polstr)
+ + ]
902 : : {
3731 rhaas@postgresql.org 903 : 11175 : QueryItem *item = (QueryItem *) lfirst(cell);
904 : :
6860 bruce@momjian.us 905 [ + + + - ]: 11175 : switch (item->type)
906 : : {
6929 teodor@sigaev.ru 907 : 6065 : case QI_VAL:
908 : 6065 : memcpy(&ptr[i], item, sizeof(QueryOperand));
909 : 6065 : break;
910 : 550 : case QI_VALSTOP:
911 : 550 : ptr[i].type = QI_VALSTOP;
912 : 550 : break;
913 : 4560 : case QI_OPR:
914 : 4560 : memcpy(&ptr[i], item, sizeof(QueryOperator));
915 : 4560 : break;
6929 teodor@sigaev.ru 916 :UBC 0 : default:
6847 tgl@sss.pgh.pa.us 917 [ # # ]: 0 : elog(ERROR, "unrecognized QueryItem type: %d", item->type);
918 : : }
6929 teodor@sigaev.ru 919 :CBC 11175 : i++;
920 : : }
921 : :
922 : : /* Copy all the operand strings to TSQuery */
1297 peter@eisentraut.org 923 : 2737 : memcpy(GETOPERAND(query), state.op, state.sumlen);
6946 tgl@sss.pgh.pa.us 924 : 2737 : pfree(state.op);
925 : :
926 : : /*
927 : : * Set left operand pointers for every operator. While we're at it,
928 : : * detect whether there are any QI_VALSTOP nodes.
929 : : */
3794 teodor@sigaev.ru 930 : 2737 : findoprnd(ptr, query->size, &needcleanup);
931 : :
932 : : /*
933 : : * If there are QI_VALSTOP nodes, delete them and simplify the tree.
934 : : */
935 [ + + ]: 2737 : if (needcleanup)
1339 tgl@sss.pgh.pa.us 936 : 355 : query = cleanup_tsquery_stopwords(query, noisy);
937 : :
6946 938 : 2737 : return query;
939 : : }
940 : :
941 : : static void
242 peter@eisentraut.org 942 : 3530 : pushval_asis(void *opaque, TSQueryParserState state, char *strval, int lenval,
943 : : int16 weight, bool prefix)
944 : : {
6677 tgl@sss.pgh.pa.us 945 : 3530 : pushValue(state, strval, lenval, weight, prefix);
6929 teodor@sigaev.ru 946 : 3530 : }
947 : :
948 : : /*
949 : : * in without morphology
950 : : */
951 : : Datum
6946 tgl@sss.pgh.pa.us 952 : 1725 : tsqueryin(PG_FUNCTION_ARGS)
953 : : {
954 : 1725 : char *in = PG_GETARG_CSTRING(0);
1339 955 : 1725 : Node *escontext = fcinfo->context;
956 : :
957 : 1725 : PG_RETURN_TSQUERY(parse_tsquery(in,
958 : : pushval_asis,
959 : : NULL,
960 : : 0,
961 : : escontext));
962 : : }
963 : :
964 : : /*
965 : : * out function
966 : : */
967 : : typedef struct
968 : : {
969 : : QueryItem *curpol; /* current query item */
970 : : char *op; /* start of tsquery's operand strings */
971 : : StringInfoData buf; /* output is accumulated here */
972 : : } INFIX;
973 : :
974 : : /*
975 : : * recursively traverse the tree and
976 : : * print it in infix (human-readable) form
977 : : */
978 : : static void
3713 teodor@sigaev.ru 979 : 4782 : infix(INFIX *in, int parentPriority, bool rightPhraseOp)
980 : : {
981 : : /* since this function recurses, it could be driven to stack overflow. */
6929 982 : 4782 : check_stack_depth();
983 : :
984 [ + + ]: 4782 : if (in->curpol->type == QI_VAL)
985 : : {
6251 peter_e@gmx.net 986 : 2763 : QueryOperand *curpol = &in->curpol->qoperand;
6929 teodor@sigaev.ru 987 : 2763 : char *op = in->op + curpol->distance;
988 : :
7 tgl@sss.pgh.pa.us 989 :GNC 2763 : appendStringInfoChar(&in->buf, '\'');
6946 tgl@sss.pgh.pa.us 990 [ + + ]:CBC 10701 : while (*op)
991 : : {
7 tgl@sss.pgh.pa.us 992 :GNC 7938 : int clen = pg_mblen_cstr(op);
993 : :
6946 tgl@sss.pgh.pa.us 994 [ + + ]:CBC 7938 : if (t_iseq(op, '\''))
7 tgl@sss.pgh.pa.us 995 :GNC 8 : appendStringInfoChar(&in->buf, '\'');
6859 teodor@sigaev.ru 996 [ + + ]:CBC 7930 : else if (t_iseq(op, '\\'))
7 tgl@sss.pgh.pa.us 997 :GNC 4 : appendStringInfoChar(&in->buf, '\\');
998 : 7938 : appendBinaryStringInfo(&in->buf, op, clen);
6946 tgl@sss.pgh.pa.us 999 :CBC 7938 : op += clen;
1000 : : }
7 tgl@sss.pgh.pa.us 1001 :GNC 2763 : appendStringInfoChar(&in->buf, '\'');
6677 tgl@sss.pgh.pa.us 1002 [ + + + + ]:CBC 2763 : if (curpol->weight || curpol->prefix)
1003 : : {
7 tgl@sss.pgh.pa.us 1004 :GNC 116 : appendStringInfoChar(&in->buf, ':');
6286 bruce@momjian.us 1005 [ + + ]:CBC 116 : if (curpol->prefix)
7 tgl@sss.pgh.pa.us 1006 :GNC 16 : appendStringInfoChar(&in->buf, '*');
6929 teodor@sigaev.ru 1007 [ + + ]:CBC 116 : if (curpol->weight & (1 << 3))
7 tgl@sss.pgh.pa.us 1008 :GNC 40 : appendStringInfoChar(&in->buf, 'A');
6929 teodor@sigaev.ru 1009 [ + + ]:CBC 116 : if (curpol->weight & (1 << 2))
7 tgl@sss.pgh.pa.us 1010 :GNC 64 : appendStringInfoChar(&in->buf, 'B');
6929 teodor@sigaev.ru 1011 [ + + ]:CBC 116 : if (curpol->weight & (1 << 1))
7 tgl@sss.pgh.pa.us 1012 :GNC 12 : appendStringInfoChar(&in->buf, 'C');
6929 teodor@sigaev.ru 1013 [ + + ]:CBC 116 : if (curpol->weight & 1)
7 tgl@sss.pgh.pa.us 1014 :GNC 4 : appendStringInfoChar(&in->buf, 'D');
1015 : : }
6946 tgl@sss.pgh.pa.us 1016 :CBC 2763 : in->curpol++;
1017 : : }
6251 peter_e@gmx.net 1018 [ + + ]: 2019 : else if (in->curpol->qoperator.oper == OP_NOT)
1019 : : {
3713 teodor@sigaev.ru 1020 : 248 : int priority = QO_PRIORITY(in->curpol);
1021 : :
3794 1022 [ - + ]: 248 : if (priority < parentPriority)
7 tgl@sss.pgh.pa.us 1023 :UNC 0 : appendStringInfoString(&in->buf, "( ");
7 tgl@sss.pgh.pa.us 1024 :GNC 248 : appendStringInfoChar(&in->buf, '!');
3794 teodor@sigaev.ru 1025 :CBC 248 : in->curpol++;
3713 1026 : 248 : infix(in, priority, false);
3794 1027 [ - + ]: 248 : if (priority < parentPriority)
7 tgl@sss.pgh.pa.us 1028 :UNC 0 : appendStringInfoString(&in->buf, " )");
1029 : : }
1030 : : else
1031 : : {
6251 peter_e@gmx.net 1032 :CBC 1771 : int8 op = in->curpol->qoperator.oper;
3713 teodor@sigaev.ru 1033 : 1771 : int priority = QO_PRIORITY(in->curpol);
3794 1034 : 1771 : int16 distance = in->curpol->qoperator.distance;
7 tgl@sss.pgh.pa.us 1035 :GNC 1771 : QueryItem *leftop = in->curpol + in->curpol->qoperator.left;
1036 : 1771 : QueryItem *rightop = in->curpol + 1;
1037 : : QueryItem *leftend;
3794 teodor@sigaev.ru 1038 :CBC 1771 : bool needParenthesis = false;
1039 : :
1040 [ + + + + ]: 1771 : if (priority < parentPriority ||
1041 : : /* phrase operator depends on order */
3664 tgl@sss.pgh.pa.us 1042 [ + + ]: 468 : (op == OP_PHRASE && rightPhraseOp))
1043 : : {
3794 teodor@sigaev.ru 1044 : 220 : needParenthesis = true;
7 tgl@sss.pgh.pa.us 1045 :GNC 220 : appendStringInfoString(&in->buf, "( ");
1046 : : }
1047 : :
1048 : : /* print left operand */
1049 : 1771 : in->curpol = leftop;
3713 teodor@sigaev.ru 1050 :CBC 1771 : infix(in, priority, false);
1051 : : /* remember end+1 of left operand */
7 tgl@sss.pgh.pa.us 1052 :GNC 1771 : leftend = in->curpol;
1053 : :
1054 : : /* print operator */
6860 bruce@momjian.us 1055 [ + + + - ]:CBC 1771 : switch (op)
1056 : : {
6929 teodor@sigaev.ru 1057 : 480 : case OP_OR:
7 tgl@sss.pgh.pa.us 1058 :GNC 480 : appendStringInfoString(&in->buf, " | ");
6929 teodor@sigaev.ru 1059 :CBC 480 : break;
1060 : 815 : case OP_AND:
7 tgl@sss.pgh.pa.us 1061 :GNC 815 : appendStringInfoString(&in->buf, " & ");
6929 teodor@sigaev.ru 1062 :CBC 815 : break;
3794 1063 : 476 : case OP_PHRASE:
1064 [ + + ]: 476 : if (distance != 1)
7 tgl@sss.pgh.pa.us 1065 :GNC 116 : appendStringInfo(&in->buf, " <%d> ", distance);
1066 : : else
1067 : 360 : appendStringInfoString(&in->buf, " <-> ");
3794 teodor@sigaev.ru 1068 :CBC 476 : break;
6929 teodor@sigaev.ru 1069 :UBC 0 : default:
1070 : : /* OP_NOT is handled in above if-branch */
6847 tgl@sss.pgh.pa.us 1071 [ # # ]: 0 : elog(ERROR, "unrecognized operator type: %d", op);
1072 : : }
1073 : :
1074 : : /* print right operand */
7 tgl@sss.pgh.pa.us 1075 :GNC 1771 : in->curpol = rightop;
1076 : 1771 : infix(in, priority, (op == OP_PHRASE));
1077 : :
1078 : : /* re-advance over left operand */
1079 [ - + ]: 1771 : Assert(in->curpol == leftop);
1080 : 1771 : in->curpol = leftend;
1081 : :
3794 teodor@sigaev.ru 1082 [ + + ]:CBC 1771 : if (needParenthesis)
7 tgl@sss.pgh.pa.us 1083 :GNC 220 : appendStringInfoString(&in->buf, " )");
1084 : : }
6946 tgl@sss.pgh.pa.us 1085 :CBC 4782 : }
1086 : :
1087 : : Datum
1088 : 1012 : tsqueryout(PG_FUNCTION_ARGS)
1089 : : {
1090 : 1012 : TSQuery query = PG_GETARG_TSQUERY(0);
1091 : : INFIX nrm;
1092 : :
1093 [ + + ]: 1012 : if (query->size == 0)
1094 : : {
1095 : 20 : char *b = palloc(1);
1096 : :
1097 : 20 : *b = '\0';
1098 : 20 : PG_RETURN_POINTER(b);
1099 : : }
1100 : 992 : nrm.curpol = GETQUERY(query);
1101 : 992 : nrm.op = GETOPERAND(query);
7 tgl@sss.pgh.pa.us 1102 :GNC 992 : initStringInfo(&nrm.buf);
3664 tgl@sss.pgh.pa.us 1103 :CBC 992 : infix(&nrm, -1 /* lowest priority */ , false);
1104 : :
6946 1105 [ - + ]: 992 : PG_FREE_IF_COPY(query, 0);
7 tgl@sss.pgh.pa.us 1106 :GNC 992 : PG_RETURN_CSTRING(nrm.buf.data);
1107 : : }
1108 : :
1109 : : /*
1110 : : * Binary Input / Output functions. The binary format is as follows:
1111 : : *
1112 : : * uint32 number of operators/operands in the query
1113 : : *
1114 : : * Followed by the operators and operands, in prefix notation. For each
1115 : : * operand:
1116 : : *
1117 : : * uint8 type, QI_VAL
1118 : : * uint8 weight
1119 : : * uint8 prefix
1120 : : * operand text in client encoding, null-terminated
1121 : : *
1122 : : * For each operator:
1123 : : *
1124 : : * uint8 type, QI_OPR
1125 : : * uint8 operator, one of OP_AND, OP_PHRASE OP_OR, OP_NOT.
1126 : : * uint16 distance (only for OP_PHRASE)
1127 : : */
1128 : : Datum
6946 tgl@sss.pgh.pa.us 1129 :UBC 0 : tsquerysend(PG_FUNCTION_ARGS)
1130 : : {
1131 : 0 : TSQuery query = PG_GETARG_TSQUERY(0);
1132 : : StringInfoData buf;
1133 : : int i;
1134 : 0 : QueryItem *item = GETQUERY(query);
1135 : :
1136 : 0 : pq_begintypsend(&buf);
1137 : :
3242 andres@anarazel.de 1138 : 0 : pq_sendint32(&buf, query->size);
6946 tgl@sss.pgh.pa.us 1139 [ # # ]: 0 : for (i = 0; i < query->size; i++)
1140 : : {
3242 andres@anarazel.de 1141 : 0 : pq_sendint8(&buf, item->type);
1142 : :
6860 bruce@momjian.us 1143 [ # # # ]: 0 : switch (item->type)
1144 : : {
6929 teodor@sigaev.ru 1145 : 0 : case QI_VAL:
3242 andres@anarazel.de 1146 : 0 : pq_sendint8(&buf, item->qoperand.weight);
1147 : 0 : pq_sendint8(&buf, item->qoperand.prefix);
6251 peter_e@gmx.net 1148 : 0 : pq_sendstring(&buf, GETOPERAND(query) + item->qoperand.distance);
6929 teodor@sigaev.ru 1149 : 0 : break;
1150 : 0 : case QI_OPR:
3242 andres@anarazel.de 1151 : 0 : pq_sendint8(&buf, item->qoperator.oper);
3794 teodor@sigaev.ru 1152 [ # # ]: 0 : if (item->qoperator.oper == OP_PHRASE)
3242 andres@anarazel.de 1153 : 0 : pq_sendint16(&buf, item->qoperator.distance);
6929 teodor@sigaev.ru 1154 : 0 : break;
1155 : 0 : default:
6847 tgl@sss.pgh.pa.us 1156 [ # # ]: 0 : elog(ERROR, "unrecognized tsquery node type: %d", item->type);
1157 : : }
6946 1158 : 0 : item++;
1159 : : }
1160 : :
1161 [ # # ]: 0 : PG_FREE_IF_COPY(query, 0);
1162 : :
1163 : 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
1164 : : }
1165 : :
1166 : : Datum
1167 : 0 : tsqueryrecv(PG_FUNCTION_ARGS)
1168 : : {
3731 rhaas@postgresql.org 1169 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
1170 : : TSQuery query;
1171 : : int len;
1172 : : QueryItem *item;
1173 : : int datalen;
1174 : : char *ptr;
1175 : : uint32 size;
1176 : : const char **operands;
1177 : : bool needcleanup;
1178 : :
6946 tgl@sss.pgh.pa.us 1179 : 0 : size = pq_getmsgint(buf, sizeof(uint32));
6929 teodor@sigaev.ru 1180 [ # # ]: 0 : if (size > (MaxAllocSize / sizeof(QueryItem)))
6946 tgl@sss.pgh.pa.us 1181 [ # # ]: 0 : elog(ERROR, "invalid size of tsquery");
1182 : :
1183 : : /* Allocate space to temporarily hold operand strings */
6929 teodor@sigaev.ru 1184 : 0 : operands = palloc(size * sizeof(char *));
1185 : :
1186 : : /* Allocate space for all the QueryItems. */
1187 : 0 : len = HDRSIZETQ + sizeof(QueryItem) * size;
1188 : 0 : query = (TSQuery) palloc0(len);
6946 tgl@sss.pgh.pa.us 1189 : 0 : query->size = size;
1190 : 0 : item = GETQUERY(query);
1191 : :
6929 teodor@sigaev.ru 1192 : 0 : datalen = 0;
47 peter@eisentraut.org 1193 [ # # ]:UNC 0 : for (uint32 i = 0; i < size; i++)
1194 : : {
6946 tgl@sss.pgh.pa.us 1195 :UBC 0 : item->type = (int8) pq_getmsgint(buf, sizeof(int8));
1196 : :
6929 teodor@sigaev.ru 1197 [ # # ]: 0 : if (item->type == QI_VAL)
1198 : : {
1199 : : size_t val_len; /* length after recoding to server
1200 : : * encoding */
1201 : : uint8 weight;
1202 : : uint8 prefix;
1203 : : const char *val;
1204 : : pg_crc32 valcrc;
1205 : :
6860 bruce@momjian.us 1206 : 0 : weight = (uint8) pq_getmsgint(buf, sizeof(uint8));
6677 tgl@sss.pgh.pa.us 1207 : 0 : prefix = (uint8) pq_getmsgint(buf, sizeof(uint8));
6929 teodor@sigaev.ru 1208 : 0 : val = pq_getmsgstring(buf);
1209 : 0 : val_len = strlen(val);
1210 : :
1211 : : /* Sanity checks */
1212 : :
1213 [ # # ]: 0 : if (weight > 0xF)
6847 tgl@sss.pgh.pa.us 1214 [ # # ]: 0 : elog(ERROR, "invalid tsquery: invalid weight bitmap");
1215 : :
10 1216 [ # # ]: 0 : if (val_len == 0)
1217 [ # # ]: 0 : elog(ERROR, "invalid tsquery: empty operand");
1218 : :
6929 teodor@sigaev.ru 1219 [ # # ]: 0 : if (val_len > MAXSTRLEN)
6847 tgl@sss.pgh.pa.us 1220 [ # # ]: 0 : elog(ERROR, "invalid tsquery: operand too long");
1221 : :
6929 teodor@sigaev.ru 1222 [ # # ]: 0 : if (datalen > MAXSTRPOS)
6847 tgl@sss.pgh.pa.us 1223 [ # # ]: 0 : elog(ERROR, "invalid tsquery: total operand length exceeded");
1224 : :
1225 : : /* Looks valid. */
1226 : :
4314 heikki.linnakangas@i 1227 : 0 : INIT_LEGACY_CRC32(valcrc);
1228 [ # # ]: 0 : COMP_LEGACY_CRC32(valcrc, val, val_len);
1229 : 0 : FIN_LEGACY_CRC32(valcrc);
1230 : :
6251 peter_e@gmx.net 1231 : 0 : item->qoperand.weight = weight;
1232 : 0 : item->qoperand.prefix = (prefix) ? true : false;
1233 : 0 : item->qoperand.valcrc = (int32) valcrc;
1234 : 0 : item->qoperand.length = val_len;
1235 : 0 : item->qoperand.distance = datalen;
1236 : :
1237 : : /*
1238 : : * Operand strings are copied to the final struct after this loop;
1239 : : * here we just collect them to an array
1240 : : */
6929 teodor@sigaev.ru 1241 : 0 : operands[i] = val;
1242 : :
3354 tgl@sss.pgh.pa.us 1243 : 0 : datalen += val_len + 1; /* + 1 for the '\0' terminator */
1244 : : }
6929 teodor@sigaev.ru 1245 [ # # ]: 0 : else if (item->type == QI_OPR)
1246 : : {
1247 : : int8 oper;
1248 : :
1249 : 0 : oper = (int8) pq_getmsgint(buf, sizeof(int8));
3794 1250 [ # # # # : 0 : if (oper != OP_NOT && oper != OP_OR && oper != OP_AND && oper != OP_PHRASE)
# # # # ]
6847 tgl@sss.pgh.pa.us 1251 [ # # ]: 0 : elog(ERROR, "invalid tsquery: unrecognized operator type %d",
1252 : : (int) oper);
6929 teodor@sigaev.ru 1253 [ # # ]: 0 : if (i == size - 1)
1254 [ # # ]: 0 : elog(ERROR, "invalid pointer to right operand");
1255 : :
6251 peter_e@gmx.net 1256 : 0 : item->qoperator.oper = oper;
3794 teodor@sigaev.ru 1257 [ # # ]: 0 : if (oper == OP_PHRASE)
1258 : : {
10 tgl@sss.pgh.pa.us 1259 : 0 : unsigned int dist = pq_getmsgint(buf, sizeof(int16));
1260 : :
1261 [ # # ]: 0 : if (dist > MAXENTRYPOS)
1262 [ # # ]: 0 : elog(ERROR, "invalid tsquery: invalid phrase distance %u",
1263 : : dist);
1264 : 0 : item->qoperator.distance = (int16) dist;
1265 : : }
1266 : : }
1267 : : else
6847 1268 [ # # ]: 0 : elog(ERROR, "unrecognized tsquery node type: %d", item->type);
1269 : :
6946 1270 : 0 : item++;
1271 : : }
1272 : :
1273 : : /* Enlarge buffer to make room for the operand values. */
1274 : 0 : query = (TSQuery) repalloc(query, len + datalen);
1275 : 0 : item = GETQUERY(query);
1276 : 0 : ptr = GETOPERAND(query);
1277 : :
1278 : : /*
1279 : : * Fill in the left-pointers. Checks that the tree is well-formed as a
1280 : : * side-effect.
1281 : : */
3794 teodor@sigaev.ru 1282 : 0 : findoprnd(item, size, &needcleanup);
1283 : :
1284 : : /* Can't have found any QI_VALSTOP nodes */
3536 tgl@sss.pgh.pa.us 1285 [ # # ]: 0 : Assert(!needcleanup);
1286 : :
1287 : : /* Copy operands to output struct */
47 peter@eisentraut.org 1288 [ # # ]:UNC 0 : for (uint32 i = 0; i < size; i++)
1289 : : {
6929 teodor@sigaev.ru 1290 [ # # ]:UBC 0 : if (item->type == QI_VAL)
1291 : : {
6251 peter_e@gmx.net 1292 : 0 : memcpy(ptr, operands[i], item->qoperand.length + 1);
1293 : 0 : ptr += item->qoperand.length + 1;
1294 : : }
6946 tgl@sss.pgh.pa.us 1295 : 0 : item++;
1296 : : }
1297 : :
6929 teodor@sigaev.ru 1298 : 0 : pfree(operands);
1299 : :
6946 tgl@sss.pgh.pa.us 1300 [ # # ]: 0 : Assert(ptr - GETOPERAND(query) == datalen);
1301 : :
1302 : 0 : SET_VARSIZE(query, len + datalen);
1303 : :
3794 teodor@sigaev.ru 1304 : 0 : PG_RETURN_TSQUERY(query);
1305 : : }
1306 : :
1307 : : /*
1308 : : * debug function, used only for view query
1309 : : * which will be executed in non-leaf pages in index
1310 : : */
1311 : : Datum
6946 tgl@sss.pgh.pa.us 1312 : 0 : tsquerytree(PG_FUNCTION_ARGS)
1313 : : {
1314 : 0 : TSQuery query = PG_GETARG_TSQUERY(0);
1315 : : INFIX nrm;
1316 : : text *res;
1317 : : QueryItem *q;
1318 : : int len;
1319 : :
1320 [ # # ]: 0 : if (query->size == 0)
1321 : : {
1322 : 0 : res = (text *) palloc(VARHDRSZ);
1323 : 0 : SET_VARSIZE(res, VARHDRSZ);
1324 : 0 : PG_RETURN_POINTER(res);
1325 : : }
1326 : :
1327 : 0 : q = clean_NOT(GETQUERY(query), &len);
1328 : :
1329 [ # # ]: 0 : if (!q)
1330 : : {
6729 1331 : 0 : res = cstring_to_text("T");
1332 : : }
1333 : : else
1334 : : {
6946 1335 : 0 : nrm.curpol = q;
1336 : 0 : nrm.op = GETOPERAND(query);
7 tgl@sss.pgh.pa.us 1337 :UNC 0 : initStringInfo(&nrm.buf);
3713 teodor@sigaev.ru 1338 :UBC 0 : infix(&nrm, -1, false);
7 tgl@sss.pgh.pa.us 1339 :UNC 0 : res = cstring_to_text_with_len(nrm.buf.data, nrm.buf.len);
6946 tgl@sss.pgh.pa.us 1340 :UBC 0 : pfree(q);
1341 : : }
1342 : :
1343 [ # # ]: 0 : PG_FREE_IF_COPY(query, 0);
1344 : :
6729 1345 : 0 : PG_RETURN_TEXT_P(res);
1346 : : }
|
