自学教程：C++ GETOPERAND函数代码示例

static intCompareTSQ(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. */TSQuerycleanup_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;}

Datumtsquery_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);}

Datumtsquery_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);}

Datumts_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);}

static voidhlfinditem(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++;	}}

TSQueryQTN2QT(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;}

Datumtsquery_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);}

Datumexectsq(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);}

static voidhlfinditem(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++;    }}

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;}

Datumgin_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);}

/* * Returns a pointer to a WordEntry's array corresponding to 'item' from * tsvector 't'. 'q' is the TSQuery containing 'item'. * Returns NULL if not found. */static WordEntry *find_wordentry(TSVector t, TSQuery q, QueryOperand *item, int32 *nitem){	WordEntry  *StopLow = ARRPTR(t);	WordEntry  *StopHigh = (WordEntry *) STRPTR(t);	WordEntry  *StopMiddle = StopHigh;	int			difference;	*nitem = 0;	/* Loop invariant: StopLow <= item < StopHigh */	while (StopLow < StopHigh)	{		StopMiddle = StopLow + (StopHigh - StopLow) / 2;		difference = WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, false);		if (difference == 0)		{			StopHigh = StopMiddle;			*nitem = 1;			break;		}		else if (difference > 0)			StopLow = StopMiddle + 1;		else			StopHigh = StopMiddle;	}	if (item->prefix)	{		if (StopLow >= StopHigh)			StopMiddle = StopHigh;		*nitem = 0;		while (StopMiddle < (WordEntry *) STRPTR(t) &&			   WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0)		{			(*nitem)++;			StopMiddle++;		}	}	return (*nitem > 0) ? StopHigh : NULL;}

Datumto_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;}

Datumplainto_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);}

Datumgin_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);}

/* * Extract data from the pg_statistic arrays into useful format. */static Selectivitymcelem_tsquery_selec(TSQuery query, Datum *mcelem, int nmcelem,					 float4 *numbers, int nnumbers){	float4		minfreq;	TextFreq   *lookup;	Selectivity selec;	int			i;	/*	 * There should be two more Numbers than Values, because the last two	 * cells are taken for minimal and maximal frequency.  Punt if not.	 *	 * (Note: the MCELEM statistics slot definition allows for a third extra	 * number containing the frequency of nulls, but we're not expecting that	 * to appear for a tsvector column.)	 */	if (nnumbers != nmcelem + 2)		return tsquery_opr_selec_no_stats(query);	/*	 * Transpose the data into a single array so we can use bsearch().	 */	lookup = (TextFreq *) palloc(sizeof(TextFreq) * nmcelem);	for (i = 0; i < nmcelem; i++)	{		/*		 * The text Datums came from an array, so it cannot be compressed or		 * stored out-of-line -- it's safe to use VARSIZE_ANY*.		 */		Assert(!VARATT_IS_COMPRESSED(mcelem[i]) && !VARATT_IS_EXTERNAL(mcelem[i]));		lookup[i].element = (text *) DatumGetPointer(mcelem[i]);		lookup[i].frequency = numbers[i];	}	/*	 * Grab the lowest frequency. compute_tsvector_stats() stored it for us in	 * the one before the last cell of the Numbers array. See ts_typanalyze.c	 */	minfreq = numbers[nnumbers - 2];	selec = tsquery_opr_selec(GETQUERY(query), GETOPERAND(query), lookup,							  nmcelem, minfreq);	pfree(lookup);	return selec;}

/* * debug function, used only for view query * which will be executed in non-leaf pages in index */Datumtsquerytree(PG_FUNCTION_ARGS){	QUERYTYPE  *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));	INFIX		nrm;	text	   *res;	ITEM	   *q;	int4		len;	if (query->size == 0)	{		res = (text *) palloc(VARHDRSZ);		VARATT_SIZEP(res) = VARHDRSZ;		PG_RETURN_POINTER(res);	}	q = clean_NOT_v2(GETQUERY(query), &len);	if (!q)	{		res = (text *) palloc(1 + VARHDRSZ);		VARATT_SIZEP(res) = 1 + VARHDRSZ;		*((char *) VARDATA(res)) = 'T';	}	else	{		nrm.curpol = q;		nrm.buflen = 32;		nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);		*(nrm.cur) = '/0';		nrm.op = GETOPERAND(query);		infix(&nrm, true);		res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ);		VARATT_SIZEP(res) = nrm.cur - nrm.buf + VARHDRSZ;		strncpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf);		pfree(q);	}	PG_FREE_IF_COPY(query, 0);	PG_RETURN_POINTER(res);}

Datumltxtq_out(PG_FUNCTION_ARGS){	ltxtquery  *query = PG_GETARG_LTXTQUERY(0);	INFIX		nrm;	if (query->size == 0)		ereport(ERROR,				(errcode(ERRCODE_SYNTAX_ERROR),				 errmsg("syntax error"),				 errdetail("Empty query.")));	nrm.curpol = GETQUERY(query);	nrm.buflen = 32;	nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);	*(nrm.cur) = '/0';	nrm.op = GETOPERAND(query);	infix(&nrm, true);	PG_FREE_IF_COPY(query, 0);	PG_RETURN_POINTER(nrm.buf);}

TSQueryQTN2QT(QTNode *in){	TSQuery		out;	int			len;	int			sumlen = 0,				nnode = 0;	QTN2QTState state;	cntsize(in, &sumlen, &nnode);	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;}

Datumltxtq_exec(PG_FUNCTION_ARGS){	ltree	   *val = PG_GETARG_LTREE(0);	ltxtquery  *query = PG_GETARG_LTXTQUERY(1);	CHKVAL		chkval;	bool		result;	chkval.node = val;	chkval.operand = GETOPERAND(query);	result = ltree_execute(						   GETQUERY(query),						   &chkval,						   true,						   checkcondition_str		);	PG_FREE_IF_COPY(val, 0);	PG_FREE_IF_COPY(query, 1);	PG_RETURN_BOOL(result);}

Datumtsquery_out(PG_FUNCTION_ARGS){	QUERYTYPE  *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));	INFIX		nrm;	if (query->size == 0)	{		char	   *b = palloc(1);		*b = '/0';		PG_RETURN_POINTER(b);	}	nrm.curpol = GETQUERY(query);	nrm.buflen = 32;	nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);	*(nrm.cur) = '/0';	nrm.op = GETOPERAND(query);	infix(&nrm, true);	PG_FREE_IF_COPY(query, 0);	PG_RETURN_POINTER(nrm.buf);}

static WordEntry *find_wordentry(tsvector * t, QUERYTYPE * q, ITEM * item){	WordEntry  *StopLow = ARRPTR(t);	WordEntry  *StopHigh = (WordEntry *) STRPTR(t);	WordEntry  *StopMiddle;	int			difference;	/* Loop invariant: StopLow <= item < StopHigh */	while (StopLow < StopHigh)	{		StopMiddle = StopLow + (StopHigh - StopLow) / 2;		difference = WordECompareITEM(STRPTR(t), GETOPERAND(q), StopMiddle, item);		if (difference == 0)			return StopMiddle;		else if (difference < 0)			StopLow = StopMiddle + 1;		else			StopHigh = StopMiddle;	}	return NULL;}

Datumtsquery_rewrite(PG_FUNCTION_ARGS){	QUERYTYPE  *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));	text	   *in = PG_GETARG_TEXT_P(1);	QUERYTYPE  *rewrited = query;	QTNode	   *tree;	char	   *buf;	void	   *plan;	Portal		portal;	bool		isnull;	int			i;	if (query->size == 0)	{		PG_FREE_IF_COPY(in, 1);		PG_RETURN_POINTER(rewrited);	}	tree = QT2QTN(GETQUERY(query), GETOPERAND(query));	QTNTernary(tree);	QTNSort(tree);	buf = (char *) palloc(VARSIZE(in));	memcpy(buf, VARDATA(in), VARSIZE(in) - VARHDRSZ);	buf[VARSIZE(in) - VARHDRSZ] = '/0';	SPI_connect();	if (tsqOid == InvalidOid)		get_tsq_Oid();	if ((plan = SPI_prepare(buf, 0, NULL)) == NULL)		elog(ERROR, "SPI_prepare('%s') returns NULL", buf);	if ((portal = SPI_cursor_open(NULL, plan, NULL, NULL, false)) == NULL)		elog(ERROR, "SPI_cursor_open('%s') returns NULL", buf);	SPI_cursor_fetch(portal, true, 100);	if (SPI_tuptable->tupdesc->natts != 2)		elog(ERROR, "number of fields doesn't equal to 2");	if (SPI_gettypeid(SPI_tuptable->tupdesc, 1) != tsqOid)		elog(ERROR, "column #1 isn't of tsquery type");	if (SPI_gettypeid(SPI_tuptable->tupdesc, 2) != tsqOid)		elog(ERROR, "column #2 isn't of tsquery type");	while (SPI_processed > 0 && tree)	{		for (i = 0; i < SPI_processed && tree; i++)		{			Datum		qdata = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull);			Datum		sdata;			if (isnull)				continue;			sdata = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull);			if (!isnull)			{				QUERYTYPE  *qtex = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(qdata));				QUERYTYPE  *qtsubs = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(sdata));				QTNode	   *qex,						   *qsubs = NULL;				if (qtex->size == 0)				{					if (qtex != (QUERYTYPE *) DatumGetPointer(qdata))						pfree(qtex);					if (qtsubs != (QUERYTYPE *) DatumGetPointer(sdata))						pfree(qtsubs);					continue;				}				qex = QT2QTN(GETQUERY(qtex), GETOPERAND(qtex));				QTNTernary(qex);				QTNSort(qex);				if (qtsubs->size)					qsubs = QT2QTN(GETQUERY(qtsubs), GETOPERAND(qtsubs));				tree = findsubquery(tree, qex, SPIMemory, qsubs, NULL);				QTNFree(qex);				if (qtex != (QUERYTYPE *) DatumGetPointer(qdata))					pfree(qtex);				QTNFree(qsubs);				if (qtsubs != (QUERYTYPE *) DatumGetPointer(sdata))					pfree(qtsubs);			}		}		SPI_freetuptable(SPI_tuptable);		SPI_cursor_fetch(portal, true, 100);	}//.........这里部分代码省略.........

Datumrewrite_accum(PG_FUNCTION_ARGS){	QUERYTYPE  *acc = (QUERYTYPE *) PG_GETARG_POINTER(0);	ArrayType  *qa = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));	QUERYTYPE  *q;	QTNode	   *qex,			   *subs = NULL,			   *acctree;	bool		isfind = false;	Datum	   *elemsp;	int			nelemsp;	AggregateContext = ((AggState *) fcinfo->context)->aggcontext;	if (acc == NULL || PG_ARGISNULL(0))	{		acc = (QUERYTYPE *) MEMALLOC(AggMemory, sizeof(QUERYTYPE));		acc->len = HDRSIZEQT;		acc->size = 0;	}	if (qa == NULL || PG_ARGISNULL(1))	{		PG_FREE_IF_COPY(qa, 1);		PG_RETURN_POINTER(acc);	}	if (ARR_NDIM(qa) != 1)		elog(ERROR, "array must be one-dimensional, not %d dimension", ARR_NDIM(qa));	if (ArrayGetNItems(ARR_NDIM(qa), ARR_DIMS(qa)) != 3)		elog(ERROR, "array should have only three elements");	if (tsqOid == InvalidOid)	{		SPI_connect();		get_tsq_Oid();		SPI_finish();	}	if (ARR_ELEMTYPE(qa) != tsqOid)		elog(ERROR, "array should contain tsquery type");	deconstruct_array(qa, tsqOid, -1, false, 'i', &elemsp, NULL, &nelemsp);	q = (QUERYTYPE *) DatumGetPointer(elemsp[0]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	if (!acc->size)	{		if (acc->len > HDRSIZEQT)		{			pfree(elemsp);			PG_RETURN_POINTER(acc);		}		else			acctree = QT2QTN(GETQUERY(q), GETOPERAND(q));	}	else		acctree = QT2QTN(GETQUERY(acc), GETOPERAND(acc));	QTNTernary(acctree);	QTNSort(acctree);	q = (QUERYTYPE *) DatumGetPointer(elemsp[1]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	qex = QT2QTN(GETQUERY(q), GETOPERAND(q));	QTNTernary(qex);	QTNSort(qex);	q = (QUERYTYPE *) DatumGetPointer(elemsp[2]);	if (q->size)		subs = QT2QTN(GETQUERY(q), GETOPERAND(q));	acctree = findsubquery(acctree, qex, PlainMemory, subs, &isfind);	if (isfind || !acc->size)	{		/* pfree( acc ); do not pfree(p), because nodeAgg.c will */		if (acctree)		{			QTNBinary(acctree);			acc = QTN2QT(acctree, AggMemory);		}		else		{			acc = (QUERYTYPE *) MEMALLOC(AggMemory, HDRSIZEQT * 2);			acc->len = HDRSIZEQT * 2;			acc->size = 0;		}	}//.........这里部分代码省略.........

Datumgin_extract_tsquery(PG_FUNCTION_ARGS){	TSQuery		query = PG_GETARG_TSQUERY(0);	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);	/* StrategyNumber strategy = PG_GETARG_UINT16(2); */	bool	  **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3);	Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);	/* bool   **nullFlags = (bool **) PG_GETARG_POINTER(5); */	int32	   *searchMode = (int32 *) PG_GETARG_POINTER(6);	Datum	   *entries = NULL;	*nentries = 0;	if (query->size > 0)	{		QueryItem  *item = GETQUERY(query);		int32		i,					j;		bool	   *partialmatch;		int		   *map_item_operand;		/*		 * If the query doesn't have any required positive matches (for		 * instance, it's something like '! foo'), we have to do a full index		 * scan.		 */		if (tsquery_requires_match(item))			*searchMode = GIN_SEARCH_MODE_DEFAULT;		else			*searchMode = GIN_SEARCH_MODE_ALL;		/* count number of VAL items */		j = 0;		for (i = 0; i < query->size; i++)		{			if (item[i].type == QI_VAL)				j++;		}		*nentries = j;		entries = (Datum *) palloc(sizeof(Datum) * j);		partialmatch = *ptr_partialmatch = (bool *) palloc(sizeof(bool) * j);		/*		 * Make map to convert item's number to corresponding operand's (the		 * same, entry's) number. Entry's number is used in check array in		 * consistent method. We use the same map for each entry.		 */		*extra_data = (Pointer *) palloc(sizeof(Pointer) * j);		map_item_operand = (int *) palloc0(sizeof(int) * query->size);		/* Now rescan the VAL items and fill in the arrays */		j = 0;		for (i = 0; i < query->size; i++)		{			if (item[i].type == QI_VAL)			{				QueryOperand *val = &item[i].qoperand;				text	   *txt;				txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,											   val->length);				entries[j] = PointerGetDatum(txt);				partialmatch[j] = val->prefix;				(*extra_data)[j] = (Pointer) map_item_operand;				map_item_operand[i] = j;				j++;			}		}	}	PG_FREE_IF_COPY(query, 0);	PG_RETURN_POINTER(entries);}

static DocRepresentation *get_docrep(tsvector * txt, QUERYTYPE * query, int *doclen){	ITEM	   *item = GETQUERY(query);	WordEntry  *entry;	WordEntryPos *post;	int4		dimt,				j,				i;	int			len = query->size * 4,				cur = 0;	DocRepresentation *doc;	char	   *operand;	*(uint16 *) POSNULL = lengthof(POSNULL) - 1;	doc = (DocRepresentation *) palloc(sizeof(DocRepresentation) * len);	operand = GETOPERAND(query);	reset_istrue_flag(query);	for (i = 0; i < query->size; i++)	{		if (item[i].type != VAL || item[i].istrue)			continue;		entry = find_wordentry(txt, query, &(item[i]));		if (!entry)			continue;		if (entry->haspos)		{			dimt = POSDATALEN(txt, entry);			post = POSDATAPTR(txt, entry);		}		else		{			dimt = *(uint16 *) POSNULL;			post = POSNULL + 1;		}		while (cur + dimt >= len)		{			len *= 2;			doc = (DocRepresentation *) repalloc(doc, sizeof(DocRepresentation) * len);		}		for (j = 0; j < dimt; j++)		{			if (j == 0)			{				ITEM	   *kptr,						   *iptr = item + i;				int			k;				doc[cur].needfree = false;				doc[cur].nitem = 0;				doc[cur].item = (ITEM **) palloc(sizeof(ITEM *) * query->size);				for (k = 0; k < query->size; k++)				{					kptr = item + k;					if (k == i ||						(item[k].type == VAL &&						 compareITEM(&kptr, &iptr, operand) == 0))					{						doc[cur].item[doc[cur].nitem] = item + k;						doc[cur].nitem++;						kptr->istrue = 1;					}				}			}			else			{				doc[cur].needfree = false;				doc[cur].nitem = doc[cur - 1].nitem;				doc[cur].item = doc[cur - 1].item;			}			doc[cur].pos = WEP_GETPOS(post[j]);			doc[cur].wclass = WEP_GETWEIGHT(post[j]);			cur++;		}	}	*doclen = cur;	if (cur > 0)	{		if (cur > 1)			qsort((void *) doc, cur, sizeof(DocRepresentation), compareDocR);		return doc;	}	pfree(doc);	return NULL;}

static floatcalc_rank_or(float *w, tsvector * t, QUERYTYPE * q){	WordEntry  *entry;	WordEntryPos *post;	int4		dimt,				j,				i;	float		res = 0.0;	ITEM	  **item;	int			size = q->size;	*(uint16 *) POSNULL = lengthof(POSNULL) - 1;	item = SortAndUniqItems(GETOPERAND(q), GETQUERY(q), &size);	for (i = 0; i < size; i++)	{		float		resj,					wjm;		int4		jm;		entry = find_wordentry(t, q, item[i]);		if (!entry)			continue;		if (entry->haspos)		{			dimt = POSDATALEN(t, entry);			post = POSDATAPTR(t, entry);		}		else		{			dimt = *(uint16 *) POSNULL;			post = POSNULL + 1;		}		resj = 0.0;		wjm = -1.0;		jm = 0;		for (j = 0; j < dimt; j++)		{			resj = resj + wpos(post[j]) / ((j + 1) * (j + 1));			if (wpos(post[j]) > wjm)			{				wjm = wpos(post[j]);				jm = j;			}		}/*		limit (sum(i/i^2),i->inf) = pi^2/6		resj = sum(wi/i^2),i=1,noccurence,		wi - should be sorted desc,		don't sort for now, just choose maximum weight. This should be corrected		Oleg Bartunov*/		res = res + (wjm + resj - wjm / ((jm + 1) * (jm + 1))) / 1.64493406685;	}	if (size > 0)		res = res / size;	pfree(item);	return res;}

static floatcalc_rank_and(float *w, tsvector * t, QUERYTYPE * q){	uint16	  **pos;	int			i,				k,				l,				p;	WordEntry  *entry;	WordEntryPos *post,			   *ct;	int4		dimt,				lenct,				dist;	float		res = -1.0;	ITEM	  **item;	int			size = q->size;	item = SortAndUniqItems(GETOPERAND(q), GETQUERY(q), &size);	if (size < 2)	{		pfree(item);		return calc_rank_or(w, t, q);	}	pos = (uint16 **) palloc(sizeof(uint16 *) * q->size);	memset(pos, 0, sizeof(uint16 *) * q->size);	*(uint16 *) POSNULL = lengthof(POSNULL) - 1;	WEP_SETPOS(POSNULL[1], MAXENTRYPOS - 1);	for (i = 0; i < size; i++)	{		entry = find_wordentry(t, q, item[i]);		if (!entry)			continue;		if (entry->haspos)			pos[i] = (uint16 *) _POSDATAPTR(t, entry);		else			pos[i] = (uint16 *) POSNULL;		dimt = *(uint16 *) (pos[i]);		post = (WordEntryPos *) (pos[i] + 1);		for (k = 0; k < i; k++)		{			if (!pos[k])				continue;			lenct = *(uint16 *) (pos[k]);			ct = (WordEntryPos *) (pos[k] + 1);			for (l = 0; l < dimt; l++)			{				for (p = 0; p < lenct; p++)				{					dist = Abs((int) WEP_GETPOS(post[l]) - (int) WEP_GETPOS(ct[p]));					if (dist || (dist == 0 && (pos[i] == (uint16 *) POSNULL || pos[k] == (uint16 *) POSNULL)))					{						float		curw;						if (!dist)							dist = MAXENTRYPOS;						curw = sqrt(wpos(post[l]) * wpos(ct[p]) * word_distance(dist));						res = (res < 0) ? curw : 1.0 - (1.0 - res) * (1.0 - curw);					}				}			}		}	}	pfree(pos);	pfree(item);	return res;}