Datum to_tsquery(PG_FUNCTION_ARGS) { text *in = PG_GETARG_TEXT_P(1); char *str; QUERYTYPE *query; ITEM *res; int4 len; SET_FUNCOID(); str = text2char(in); PG_FREE_IF_COPY(in, 1); query = queryin(str, pushval_morph, PG_GETARG_INT32(0)); res = clean_fakeval_v2(GETQUERY(query), &len); if (!res) { query->len = HDRSIZEQT; query->size = 0; PG_RETURN_POINTER(query); } memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(ITEM)); pfree(res); PG_RETURN_POINTER(query); }
Datum gin_ts_consistent(PG_FUNCTION_ARGS) { bool *check = (bool *) PG_GETARG_POINTER(0); QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(2)); bool res = FALSE; if (query->size > 0) { int4 i, j = 0; ITEM *item; GinChkVal gcv; gcv.frst = item = GETQUERY(query); gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size); for (i = 0; i < query->size; i++) if (item[i].type == VAL) gcv.mapped_check[i] = check[j++]; res = TS_execute( GETQUERY(query), &gcv, true, checkcondition_gin ); } PG_FREE_IF_COPY(query, 2); PG_RETURN_BOOL(res); }
bool gin_bool_consistent(QUERYTYPE *query, bool *check) { GinChkVal gcv; ITEM *items = GETQUERY(query); int i, j = 0; if (query->size <= 0) return FALSE; /* * Set up data for checkcondition_gin. This must agree with the * query extraction code in ginint4_queryextract. */ gcv.first = items; gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size); for (i = 0; i < query->size; i++) { if (items[i].type == VAL) gcv.mapped_check[i] = check[j++]; } return execute(GETQUERY(query) + query->size - 1, (void *) &gcv, true, checkcondition_gin); }
static int CompareTSQ(TSQuery a, TSQuery b) { if (a->size != b->size) { return (a->size < b->size) ? -1 : 1; } else if (VARSIZE(a) != VARSIZE(b)) { return (VARSIZE(a) < VARSIZE(b)) ? -1 : 1; } else if (a->size != 0) { QTNode *an = QT2QTN(GETQUERY(a), GETOPERAND(a)); QTNode *bn = QT2QTN(GETQUERY(b), GETOPERAND(b)); int res = QTNodeCompare(an, bn); QTNFree(an); QTNFree(bn); return res; } return 0; }
/* * Remove QI_VALSTOP (stopword) nodes from TSQuery. */ TSQuery cleanup_tsquery_stopwords(TSQuery in) { int32 len, lenstr, commonlen, i; NODE *root; int ladd, radd; TSQuery out; QueryItem *items; char *operands; if (in->size == 0) return in; /* eliminate stop words */ root = clean_stopword_intree(maketree(GETQUERY(in)), &ladd, &radd); if (root == NULL) { ereport(NOTICE, (errmsg("text-search query contains only stop words or doesn't contain lexemes, ignored"))); out = palloc(HDRSIZETQ); out->size = 0; SET_VARSIZE(out, HDRSIZETQ); return out; } /* * Build TSQuery from plain view */ lenstr = calcstrlen(root); items = plaintree(root, &len); commonlen = COMPUTESIZE(len, lenstr); out = palloc(commonlen); SET_VARSIZE(out, commonlen); out->size = len; memcpy(GETQUERY(out), items, len * sizeof(QueryItem)); items = GETQUERY(out); operands = GETOPERAND(out); for (i = 0; i < out->size; i++) { QueryOperand *op = (QueryOperand *) &items[i]; if (op->type != QI_VAL) continue; memcpy(operands, GETOPERAND(in) + op->distance, op->length); operands[op->length] = '\0'; op->distance = operands - GETOPERAND(out); operands += op->length + 1; } return out; }
datum_t gin_tsquery_consistent(PG_FUNC_ARGS) { bool *check = (bool *) ARG_POINTER(0); /* strat_nr_t strategy = ARG_UINT16(1); */ TSQuery query = ARG_TSQUERY(2); /* int32 nkeys = ARG_INT32(3); */ pointer_p *extra_data = (pointer_p *) ARG_POINTER(4); bool *recheck = (bool *) ARG_POINTER(5); bool res = FALSE; /* The query requires recheck only if it involves weights */ *recheck = false; if (query->size > 0) { QueryItem *item; GinChkVal gcv; /* * check-parameter array has one entry for each value (operand) in the * query. */ gcv.first_item = item = GETQUERY(query); gcv.check = check; gcv.map_item_operand = (int *)(extra_data[0]); gcv.need_recheck = recheck; res = TS_execute(GETQUERY(query), &gcv, true, checkcondition_gin); } RET_BOOL(res); }
Datum gin_extract_tsquery(PG_FUNCTION_ARGS) { TSQuery query = PG_GETARG_TSQUERY(0); int32 *nentries = (int32 *) PG_GETARG_POINTER(1); StrategyNumber strategy = PG_GETARG_UINT16(2); Datum *entries = NULL; *nentries = 0; if (query->size > 0) { int4 i, j = 0, len; QueryItem *item; item = clean_NOT(GETQUERY(query), &len); if (!item) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("query requires full scan, which is not supported by GIN indexes"))); item = GETQUERY(query); for (i = 0; i < query->size; i++) if (item[i].type == QI_VAL) (*nentries)++; entries = (Datum *) palloc(sizeof(Datum) * (*nentries)); for (i = 0; i < query->size; i++) if (item[i].type == QI_VAL) { text *txt; QueryOperand *val = &item[i].operand; txt = (text *) palloc(VARHDRSZ + val->length); SET_VARSIZE(txt, VARHDRSZ + val->length); memcpy(VARDATA(txt), GETOPERAND(query) + val->distance, val->length); entries[j++] = PointerGetDatum(txt); if (strategy != TSearchWithClassStrategyNumber && val->weight != 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("@@ operator does not support lexeme weight restrictions in GIN index searches"), errhint("Use the @@@ operator instead."))); } } else *nentries = -1; /* nothing can be found */ PG_FREE_IF_COPY(query, 0); PG_RETURN_POINTER(entries); }
Datum tsq_mcontains(PG_FUNCTION_ARGS) { TSQuery query = PG_GETARG_TSQUERY(0); TSQuery ex = PG_GETARG_TSQUERY(1); TSQuerySign sq, se; int i, j; QueryItem *iq, *ie; if (query->size < ex->size) { PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_RETURN_BOOL(false); } sq = makeTSQuerySign(query); se = makeTSQuerySign(ex); if ((sq & se) != se) { PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_RETURN_BOOL(false); } iq = GETQUERY(query); ie = GETQUERY(ex); for (i = 0; i < ex->size; i++) { if (ie[i].type != QI_VAL) continue; for (j = 0; j < query->size; j++) { if (iq[j].type == QI_VAL && ie[i].qoperand.valcrc == iq[j].qoperand.valcrc) break; } if (j >= query->size) { PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_RETURN_BOOL(false); } } PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_RETURN_BOOL(true); }
Datum tsquery_rewrite(PG_FUNCTION_ARGS) { TSQuery query = PG_GETARG_TSQUERY_COPY(0); TSQuery ex = PG_GETARG_TSQUERY(1); TSQuery subst = PG_GETARG_TSQUERY(2); TSQuery rewrited = query; QTNode *tree, *qex, *subs = NULL; if (query->size == 0 || ex->size == 0) { PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); } tree = QT2QTN(GETQUERY(query), GETOPERAND(query)); QTNTernary(tree); QTNSort(tree); qex = QT2QTN(GETQUERY(ex), GETOPERAND(ex)); QTNTernary(qex); QTNSort(qex); if (subst->size) subs = QT2QTN(GETQUERY(subst), GETOPERAND(subst)); tree = findsubquery(tree, qex, subs, NULL); QTNFree(qex); QTNFree(subs); if (!tree) { SET_VARSIZE(rewrited, HDRSIZETQ); rewrited->size = 0; PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); } else { QTNBinary(tree); rewrited = QTN2QT(tree); QTNFree(tree); } PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); }
Datum tsquery_rewrite_query(PG_FUNCTION_ARGS) { QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0))); QUERYTYPE *ex = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); QUERYTYPE *subst = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(2))); QUERYTYPE *rewrited = query; QTNode *tree, *qex, *subs = NULL; if (query->size == 0 || ex->size == 0) { PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); } tree = QT2QTN(GETQUERY(query), GETOPERAND(query)); QTNTernary(tree); QTNSort(tree); qex = QT2QTN(GETQUERY(ex), GETOPERAND(ex)); QTNTernary(qex); QTNSort(qex); if (subst->size) subs = QT2QTN(GETQUERY(subst), GETOPERAND(subst)); tree = findsubquery(tree, qex, PlainMemory, subs, NULL); QTNFree(qex); QTNFree(subs); if (!tree) { rewrited->len = HDRSIZEQT; rewrited->size = 0; PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); } else { QTNBinary(tree); rewrited = QTN2QT(tree, PlainMemory); QTNFree(tree); } PG_FREE_IF_COPY(query, 0); PG_FREE_IF_COPY(ex, 1); PG_FREE_IF_COPY(subst, 2); PG_RETURN_POINTER(rewrited); }
Datum gin_extract_tsquery(PG_FUNCTION_ARGS) { QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0)); uint32 *nentries = (uint32 *) PG_GETARG_POINTER(1); StrategyNumber strategy = DatumGetUInt16(PG_GETARG_DATUM(2)); Datum *entries = NULL; *nentries = 0; if (query->size > 0) { int4 i, j = 0, len; ITEM *item; item = clean_NOT_v2(GETQUERY(query), &len); if (!item) elog(ERROR, "Query requires full scan, GIN doesn't support it"); item = GETQUERY(query); for (i = 0; i < query->size; i++) if (item[i].type == VAL) (*nentries)++; entries = (Datum *) palloc(sizeof(Datum) * (*nentries)); for (i = 0; i < query->size; i++) if (item[i].type == VAL) { text *txt; txt = (text *) palloc(VARHDRSZ + item[i].length); VARATT_SIZEP(txt) = VARHDRSZ + item[i].length; memcpy(VARDATA(txt), GETOPERAND(query) + item[i].distance, item[i].length); entries[j++] = PointerGetDatum(txt); if (strategy == 1 && item[i].weight != 0) elog(ERROR, "With class of lexeme restrictions use @@@ operation"); } } PG_FREE_IF_COPY(query, 0); PG_RETURN_POINTER(entries); }
static void hlfinditem(HeadlineParsedText *prs, TSQuery query, char *buf, int buflen) { int i; QueryItem *item = GETQUERY(query); HeadlineWordEntry *word; while (prs->curwords + query->size >= prs->lenwords) { prs->lenwords *= 2; prs->words = (HeadlineWordEntry *) repalloc((void *) prs->words, prs->lenwords * sizeof(HeadlineWordEntry)); } word = &(prs->words[prs->curwords - 1]); for (i = 0; i < query->size; i++) { if (item->type == QI_VAL && tsCompareString(GETOPERAND(query) + item->qoperand.distance, item->qoperand.length, buf, buflen, item->qoperand.prefix) == 0) { if (word->item) { memcpy(&(prs->words[prs->curwords]), word, sizeof(HeadlineWordEntry)); prs->words[prs->curwords].item = &item->qoperand; prs->words[prs->curwords].repeated = 1; prs->curwords++; } else word->item = &item->qoperand; } item++; } }
TSQuery QTN2QT(QTNode *in) { TSQuery out; int len; int sumlen = 0, nnode = 0; QTN2QTState state; cntsize(in, &sumlen, &nnode); if (TSQUERY_TOO_BIG(nnode, sumlen)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("tsquery is too large"))); len = COMPUTESIZE(nnode, sumlen); out = (TSQuery) palloc0(len); SET_VARSIZE(out, len); out->size = nnode; state.curitem = GETQUERY(out); state.operand = state.curoperand = GETOPERAND(out); fillQT(&state, in); return out; }
static void hlfinditem(HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int buflen) { int i; ITEM *item = GETQUERY(query); HLWORD *word; while (prs->curwords + query->size >= prs->lenwords) { prs->lenwords *= 2; prs->words = (HLWORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(HLWORD)); } word = &(prs->words[prs->curwords - 1]); for (i = 0; i < query->size; i++) { if (item->type == VAL && item->length == buflen && strncmp(GETOPERAND(query) + item->distance, buf, buflen) == 0) { if (word->item) { memcpy(&(prs->words[prs->curwords]), word, sizeof(HLWORD)); prs->words[prs->curwords].item = item; prs->words[prs->curwords].repeated = 1; prs->curwords++; } else word->item = item; } item++; } }
Datum tsquery_not(PG_FUNCTION_ARGS) { TSQuery a = PG_GETARG_TSQUERY_COPY(0); QTNode *res; TSQuery query; if (a->size == 0) PG_RETURN_POINTER(a); res = (QTNode *) palloc0(sizeof(QTNode)); res->flags |= QTN_NEEDFREE; res->valnode = (QueryItem *) palloc0(sizeof(QueryItem)); res->valnode->type = QI_OPR; res->valnode->qoperator.oper = OP_NOT; res->child = (QTNode **) palloc0(sizeof(QTNode *)); res->child[0] = QT2QTN(GETQUERY(a), GETOPERAND(a)); res->nchild = 1; query = QTN2QT(res); QTNFree(res); PG_FREE_IF_COPY(a, 0); PG_RETURN_POINTER(query); }
bool query_has_required_values(QUERYTYPE *query) { if (query->size <= 0) return false; return contains_required_value(GETQUERY(query) + query->size - 1); }
Datum ts_match_vq(PG_FUNCTION_ARGS) { TSVector val = PG_GETARG_TSVECTOR(0); TSQuery query = PG_GETARG_TSQUERY(1); CHKVAL chkval; bool result; if (!val->size || !query->size) { PG_FREE_IF_COPY(val, 0); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(false); } chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + val->size; chkval.values = STRPTR(val); chkval.operand = GETOPERAND(query); result = TS_execute( GETQUERY(query), &chkval, true, checkcondition_str ); PG_FREE_IF_COPY(val, 0); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(result); }
Datum boolop(PG_FUNCTION_ARGS) { ArrayType *val = (ArrayType *) PG_DETOAST_DATUM_COPY(PG_GETARG_POINTER(0)); QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1)); CHKVAL chkval; bool result; CHECKARRVALID(val); if (ARRISVOID(val)) { pfree(val); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(false); } PREPAREARR(val); chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + ARRNELEMS(val); result = execute( GETQUERY(query) + query->size - 1, &chkval, true, checkcondition_arr ); pfree(val); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(result); }
static float calc_rank(float *w, tsvector * t, QUERYTYPE * q, int4 method) { ITEM *item = GETQUERY(q); float res = 0.0; int len; if (!t->size || !q->size) return 0.0; res = (item->type != VAL && item->val == (int4) '&') ? calc_rank_and(w, t, q) : calc_rank_or(w, t, q); if (res < 0) res = 1e-20; if ((method & RANK_NORM_LOGLENGTH) && t->size > 0) res /= log((double) (cnt_length(t) + 1)) / log(2.0); if (method & RANK_NORM_LENGTH) { len = cnt_length(t); if (len > 0) res /= (float) len; } if ((method & RANK_NORM_UNIQ) && t->size > 0) res /= (float) (t->size); if ((method & RANK_NORM_LOGUNIQ) && t->size > 0) res /= log((double) (t->size + 1)) / log(2.0); return res; }
Datum exectsq(PG_FUNCTION_ARGS) { tsvector *val = (tsvector *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); CHKVAL chkval; bool result; SET_FUNCOID(); if (!val->size || !query->size) { PG_FREE_IF_COPY(val, 0); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(false); } chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + val->size; chkval.values = STRPTR(val); chkval.operand = GETOPERAND(query); result = TS_execute( GETQUERY(query), &chkval, true, checkcondition_str ); PG_FREE_IF_COPY(val, 0); PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(result); }
/* * signconsistent & execconsistent called by *_consistent */ bool signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot) { return execute(GETQUERY(query) + query->size - 1, (void *) sign, calcnot, checkcondition_bit); }
static QTNode *join_tsqueries(TSQuery a, TSQuery b, int8 operator) { QTNode *res = (QTNode *) pzalloc(sizeof(QTNode)); res->flags |= QTN_NEEDFREE; res->valnode = (QueryItem *) pzalloc(sizeof(QueryItem)); res->valnode->type = QI_OPR; res->valnode->qoperator.oper = operator; res->child = (QTNode **) pzalloc(sizeof(QTNode *) * 2); res->child[0] = QT2QTN(GETQUERY(b), GETOPERAND(b)); res->child[1] = QT2QTN(GETQUERY(a), GETOPERAND(a)); res->nchild = 2; return res; }
Datum to_tsquery_byid(PG_FUNCTION_ARGS) { Oid cfgid = PG_GETARG_OID(0); text *in = PG_GETARG_TEXT_P(1); TSQuery query; QueryItem *res; int4 len; query = parse_tsquery(text_to_cstring(in), pushval_morph, ObjectIdGetDatum(cfgid), false); if (query->size == 0) PG_RETURN_TSQUERY(query); /* clean out any stopword placeholders from the tree */ res = clean_fakeval(GETQUERY(query), &len); if (!res) { SET_VARSIZE(query, HDRSIZETQ); query->size = 0; PG_RETURN_POINTER(query); } memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(QueryItem)); /* * Removing the stopword placeholders might've resulted in fewer * QueryItems. If so, move the operands up accordingly. */ if (len != query->size) { char *oldoperand = GETOPERAND(query); int4 lenoperand = VARSIZE(query) - (oldoperand - (char *) query); Assert(len < query->size); query->size = len; memmove((void *) GETOPERAND(query), oldoperand, VARSIZE(query) - (oldoperand - (char *) query)); SET_VARSIZE(query, COMPUTESIZE(len, lenoperand)); } pfree(res); PG_RETURN_TSQUERY(query); }
static QTNode * join_tsqueries(TSQuery a, TSQuery b, int8 operator, uint16 distance) { QTNode *res = (QTNode *) palloc0(sizeof(QTNode)); res->flags |= QTN_NEEDFREE; res->valnode = (QueryItem *) palloc0(sizeof(QueryItem)); res->valnode->type = QI_OPR; res->valnode->qoperator.oper = operator; if (operator == OP_PHRASE) res->valnode->qoperator.distance = distance; res->child = (QTNode **) palloc0(sizeof(QTNode *) * 2); res->child[0] = QT2QTN(GETQUERY(b), GETOPERAND(b)); res->child[1] = QT2QTN(GETQUERY(a), GETOPERAND(a)); res->nchild = 2; return res; }
/* Array must be sorted! */ bool execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot) { CHKVAL chkval; CHECKARRVALID(array); chkval.arrb = ARRPTR(array); chkval.arre = chkval.arrb + ARRNELEMS(array); return execute(GETQUERY(query) + query->size - 1, (void *) &chkval, calcnot, checkcondition_arr); }
Datum gin_tsquery_triconsistent(PG_FUNCTION_ARGS) { GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0); /* StrategyNumber strategy = PG_GETARG_UINT16(1); */ TSQuery query = PG_GETARG_TSQUERY(2); /* int32 nkeys = PG_GETARG_INT32(3); */ Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); GinTernaryValue res = GIN_FALSE; bool recheck; /* The query requires recheck only if it involves weights */ recheck = false; if (query->size > 0) { QueryItem *item; GinChkVal gcv; /* * check-parameter array has one entry for each value (operand) in the * query. */ gcv.first_item = item = GETQUERY(query); gcv.check = check; gcv.map_item_operand = (int *) (extra_data[0]); gcv.need_recheck = &recheck; res = TS_execute_ternary(GETQUERY(query), &gcv, checkcondition_gin); if (res == GIN_TRUE && recheck) res = GIN_MAYBE; } PG_RETURN_GIN_TERNARY_VALUE(res); }
Datum gin_tsquery_consistent(PG_FUNCTION_ARGS) { bool *check = (bool *) PG_GETARG_POINTER(0); /* StrategyNumber strategy = PG_GETARG_UINT16(1); */ TSQuery query = PG_GETARG_TSQUERY(2); bool res = FALSE; if (query->size > 0) { int i, j = 0; QueryItem *item; GinChkVal gcv; /* * check-parameter array has one entry for each value (operand) in the * query. We expand that array into mapped_check, so that there's one * entry in mapped_check for every node in the query, including * operators, to allow quick lookups in checkcondition_gin. Only the * entries corresponding operands are actually used. */ gcv.frst = item = GETQUERY(query); gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size); for (i = 0; i < query->size; i++) if (item[i].type == QI_VAL) gcv.mapped_check[i] = check[j++]; res = TS_execute( GETQUERY(query), &gcv, true, checkcondition_gin ); } PG_RETURN_BOOL(res); }
Datum gin_tsquery_consistent(PG_FUNCTION_ARGS) { bool *check = (bool *) PG_GETARG_POINTER(0); /* StrategyNumber strategy = PG_GETARG_UINT16(1); */ TSQuery query = PG_GETARG_TSQUERY(2); /* int32 nkeys = PG_GETARG_INT32(3); */ Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); bool *recheck = (bool *) PG_GETARG_POINTER(5); bool res = FALSE; /* The query requires recheck only if it involves weights */ *recheck = false; if (query->size > 0) { QueryItem *item; GinChkVal gcv; /* * check-parameter array has one entry for each value (operand) in the * query. */ gcv.first_item = item = GETQUERY(query); gcv.check = reinterpret_cast<char *>(check); gcv.map_item_operand = (int *) (extra_data[0]); gcv.need_recheck = recheck; res = TS_execute(GETQUERY(query), &gcv, true, reinterpret_cast<bool (*)(void*, QueryOperand*)>(checkcondition_gin)); } PG_RETURN_BOOL(res); }
Datum plainto_tsquery_byid(PG_FUNCTION_ARGS) { Oid cfgid = PG_GETARG_OID(0); text *in = PG_GETARG_TEXT_P(1); TSQuery query; QueryItem *res; int4 len; query = parse_tsquery(text_to_cstring(in), pushval_morph, ObjectIdGetDatum(cfgid), true); if (query->size == 0) PG_RETURN_TSQUERY(query); res = clean_fakeval(GETQUERY(query), &len); if (!res) { SET_VARSIZE(query, HDRSIZETQ); query->size = 0; PG_RETURN_POINTER(query); } memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(QueryItem)); if (len != query->size) { char *oldoperand = GETOPERAND(query); int4 lenoperand = VARSIZE(query) - (oldoperand - (char *) query); Assert(len < query->size); query->size = len; memcpy((void *) GETOPERAND(query), oldoperand, lenoperand); SET_VARSIZE(query, COMPUTESIZE(len, lenoperand)); } pfree(res); PG_RETURN_POINTER(query); }
bool ginconsistent(QUERYTYPE *query, bool *check) { GinChkVal gcv; ITEM *items = GETQUERY(query); int i, j = 0; if (query->size < 0) return FALSE; gcv.first = items; gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size); for (i = 0; i < query->size; i++) if (items[i].type == VAL) gcv.mapped_check[i] = check[j++]; return execute( GETQUERY(query) + query->size - 1, (void *) &gcv, true, checkcondition_gin ); }