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

Datumg_int_union(PG_FUNCTION_ARGS){    GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);    int		   *size = (int *) PG_GETARG_POINTER(1);    int4		i;    ArrayType  *res;    int			totlen = 0,                *ptr;    for (i = 0; i < entryvec->n; i++)        totlen += ARRNELEMS(GETENTRY(entryvec, i));    res = new_intArrayType(totlen);    ptr = ARRPTR(res);    for (i = 0; i < entryvec->n; i++)    {        memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));        ptr += ARRNELEMS(GETENTRY(entryvec, i));    }    QSORT(res, 1);    res = _int_unique(res);    *size = VARSIZE(res);    PG_RETURN_POINTER(res);}

Datumg_int_same(PG_FUNCTION_ARGS){	ArrayType  *a = (ArrayType *) PointerGetDatum(PG_GETARG_POINTER(0));	ArrayType  *b = (ArrayType *) PointerGetDatum(PG_GETARG_POINTER(1));	bool	   *result = (bool *) PG_GETARG_POINTER(2);	int4		n = ARRNELEMS(a);	int4	   *da,			   *db;	CHECKARRVALID(a);	CHECKARRVALID(b);	if (n != ARRNELEMS(b))	{		*result = false;		PG_RETURN_POINTER(result);	}	*result = TRUE;	da = ARRPTR(a);	db = ARRPTR(b);	while (n--)		if (*da++ != *db++)		{			*result = FALSE;			break;		}	PG_RETURN_POINTER(result);}

Datumg_int_union(PG_FUNCTION_ARGS){	bytea	   *entryvec = (bytea *) PG_GETARG_POINTER(0);	int		   *size = (int *) PG_GETARG_POINTER(1);	int4		i,				len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);	ArrayType  *res;	int			totlen = 0,			   *ptr;	for (i = 0; i < len; i++)		totlen += ARRNELEMS(GETENTRY(entryvec, i));	res = new_intArrayType(totlen);	ptr = ARRPTR(res);	for (i = 0; i < len; i++)	{		memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));		ptr += ARRNELEMS(GETENTRY(entryvec, i));	}	QSORT(res, 1);	res = _int_unique(res);	*size = VARSIZE(res);	PG_RETURN_POINTER(res);}

Datumg_int_same(PG_FUNCTION_ARGS){	ArrayType  *a = PG_GETARG_ARRAYTYPE_P(0);	ArrayType  *b = PG_GETARG_ARRAYTYPE_P(1);	bool	   *result = (bool *) PG_GETARG_POINTER(2);	int32		n = ARRNELEMS(a);	int32	   *da,			   *db;	CHECKARRVALID(a);	CHECKARRVALID(b);	if (n != ARRNELEMS(b))	{		*result = false;		PG_RETURN_POINTER(result);	}	*result = TRUE;	da = ARRPTR(a);	db = ARRPTR(b);	while (n--)	{		if (*da++ != *db++)		{			*result = FALSE;			break;		}	}	PG_RETURN_POINTER(result);}

/* arguments are assumed sorted */boolinner_int_overlap(ArrayType *a, ArrayType *b){	int			na,				nb;	int			i,				j;	int		   *da,			   *db;	na = ARRNELEMS(a);	nb = ARRNELEMS(b);	da = ARRPTR(a);	db = ARRPTR(b);	i = j = 0;	while (i < na && j < nb)	{		if (da[i] < db[j])			i++;		else if (da[i] == db[j])			return TRUE;		else			j++;	}	return FALSE;}

Datumtsvector_strip(PG_FUNCTION_ARGS){	TSVector	in = PG_GETARG_TSVECTOR(0);	TSVector	out;	int			i,				len = 0;	WordEntry  *arrin = ARRPTR(in),			   *arrout;	char	   *cur;	for (i = 0; i < in->size; i++)		len += arrin[i].len;	len = CALCDATASIZE(in->size, len);	out = (TSVector) palloc0(len);	SET_VARSIZE(out, len);	out->size = in->size;	arrout = ARRPTR(out);	cur = STRPTR(out);	for (i = 0; i < in->size; i++)	{		memcpy(cur, STRPTR(in) + arrin[i].pos, arrin[i].len);		arrout[i].haspos = 0;		arrout[i].len = arrin[i].len;		arrout[i].pos = cur - STRPTR(out);		cur += arrout[i].len;	}	PG_FREE_IF_COPY(in, 0);	PG_RETURN_POINTER(out);}

/* arguments are assumed sorted & unique-ified */boolinner_int_contains(ArrayType *a, ArrayType *b){	int			na,				nb;	int			i,				j,				n;	int		   *da,			   *db;	na = ARRNELEMS(a);	nb = ARRNELEMS(b);	da = ARRPTR(a);	db = ARRPTR(b);	i = j = n = 0;	while (i < na && j < nb)	{		if (da[i] < db[j])			i++;		else if (da[i] == db[j])		{			n++;			i++;			j++;		}		else			break;				/* db[j] is not in da */	}	return (n == nb) ? TRUE : FALSE;}

/* * Order: haspos, len, word, for all positions (pos, weight) */static intsilly_cmp_tsvector(const TSVector a, const TSVector b){	if (VARSIZE(a) < VARSIZE(b))		return -1;	else if (VARSIZE(a) > VARSIZE(b))		return 1;	else if (a->size < b->size)		return -1;	else if (a->size > b->size)		return 1;	else	{		WordEntry  *aptr = ARRPTR(a);		WordEntry  *bptr = ARRPTR(b);		int			i = 0;		int			res;		for (i = 0; i < a->size; i++)		{			if (aptr->haspos != bptr->haspos)			{				return (aptr->haspos > bptr->haspos) ? -1 : 1;			}			else if ((res = tsCompareString(STRPTR(a) + aptr->pos, aptr->len, STRPTR(b) + bptr->pos, bptr->len, false)) != 0)			{				return res;			}			else if (aptr->haspos)			{				WordEntryPos *ap = POSDATAPTR(a, aptr);				WordEntryPos *bp = POSDATAPTR(b, bptr);				int			j;				if (POSDATALEN(a, aptr) != POSDATALEN(b, bptr))					return (POSDATALEN(a, aptr) > POSDATALEN(b, bptr)) ? -1 : 1;				for (j = 0; j < POSDATALEN(a, aptr); j++)				{					if (WEP_GETPOS(*ap) != WEP_GETPOS(*bp))					{						return (WEP_GETPOS(*ap) > WEP_GETPOS(*bp)) ? -1 : 1;					}					else if (WEP_GETWEIGHT(*ap) != WEP_GETWEIGHT(*bp))					{						return (WEP_GETWEIGHT(*ap) > WEP_GETWEIGHT(*bp)) ? -1 : 1;					}					ap++, bp++;				}			}			aptr++;			bptr++;		}	}	return 0;}

ArrayType *inner_int_union(ArrayType *a, ArrayType *b){	ArrayType  *r = NULL;	CHECKARRVALID(a);	CHECKARRVALID(b);	if (ARRISEMPTY(a) && ARRISEMPTY(b))		return new_intArrayType(0);	if (ARRISEMPTY(a))		r = copy_intArrayType(b);	if (ARRISEMPTY(b))		r = copy_intArrayType(a);	if (!r)	{		int			na = ARRNELEMS(a),					nb = ARRNELEMS(b);		int		   *da = ARRPTR(a),				   *db = ARRPTR(b);		int			i,					j,				   *dr;		r = new_intArrayType(na + nb);		dr = ARRPTR(r);		/* union */		i = j = 0;		while (i < na && j < nb)		{			if (da[i] == db[j])			{				*dr++ = da[i++];				j++;			}			else if (da[i] < db[j])				*dr++ = da[i++];			else				*dr++ = db[j++];		}		while (i < na)			*dr++ = da[i++];		while (j < nb)			*dr++ = db[j++];		r = resize_intArrayType(r, dr - ARRPTR(r));	}	if (ARRNELEMS(r) > 1)		r = _int_unique(r);	return r;}

ArrayType *copy_intArrayType(ArrayType *a){	ArrayType  *r;	int			n = ARRNELEMS(a);	r = new_intArrayType(n);	memcpy(ARRPTR(r), ARRPTR(a), n * sizeof(int4));	return r;}

Datumg_int_decompress(PG_FUNCTION_ARGS){    GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);    GISTENTRY  *retval;    ArrayType  *r;    int		   *dr,               lenr;    ArrayType  *in;    int			lenin;    int		   *din;    int			i,                j;    in = (ArrayType *) PG_DETOAST_DATUM(entry->key);    if (ARRISVOID(in))        PG_RETURN_POINTER(entry);    lenin = ARRNELEMS(in);    if (lenin < 2 * MAXNUMRANGE || ISLEAFKEY(in))    {   /* not compressed value */        if (in != (ArrayType *) DatumGetPointer(entry->key))        {            retval = palloc(sizeof(GISTENTRY));            gistentryinit(*retval, PointerGetDatum(in),                          entry->rel, entry->page, entry->offset, VARSIZE(in), FALSE);            PG_RETURN_POINTER(retval);        }        PG_RETURN_POINTER(entry);    }    din = ARRPTR(in);    lenr = internal_size(din, lenin);    r = new_intArrayType(lenr);    dr = ARRPTR(r);    for (i = 0; i < lenin; i += 2)        for (j = din[i]; j <= din[i + 1]; j++)            if ((!i) || *(dr - 1) != j)                *dr++ = j;    if (in != (ArrayType *) DatumGetPointer(entry->key))        pfree(in);    retval = palloc(sizeof(GISTENTRY));    gistentryinit(*retval, PointerGetDatum(r),                  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);    PG_RETURN_POINTER(retval);}

Datumsubarray(PG_FUNCTION_ARGS){	ArrayType  *a = (ArrayType *) PG_GETARG_ARRAYTYPE_P(0);	int32		start = PG_GETARG_INT32(1);	int32		len = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;	int32		end = 0;	int32		c;	ArrayType  *result;	start = (start > 0) ? start - 1 : start;	CHECKARRVALID(a);	if (ARRISEMPTY(a))	{		PG_FREE_IF_COPY(a, 0);		PG_RETURN_POINTER(new_intArrayType(0));	}	c = ARRNELEMS(a);	if (start < 0)		start = c + start;	if (len < 0)		end = c + len;	else if (len == 0)		end = c;	else		end = start + len;	if (end > c)		end = c;	if (start < 0)		start = 0;	if (start >= end || end <= 0)	{		PG_FREE_IF_COPY(a, 0);		PG_RETURN_POINTER(new_intArrayType(0));	}	result = new_intArrayType(end - start);	if (end - start > 0)		memcpy(ARRPTR(result), ARRPTR(a) + start, (end - start) * sizeof(int32));	PG_FREE_IF_COPY(a, 0);	PG_RETURN_POINTER(result);}

HStore *hstorePairs(Pairs *pairs, int4 pcount, int4 buflen){	HStore	   *out;	HEntry	   *entry;	char	   *ptr;	char	   *buf;	int4		len;	int4		i;	len = CALCDATASIZE(pcount, buflen);	out = palloc(len);	SET_VARSIZE(out, len);	HS_SETCOUNT(out, pcount);	if (pcount == 0)		return out;	entry = ARRPTR(out);	buf = ptr = STRPTR(out);	for (i = 0; i < pcount; i++)		HS_ADDITEM(entry, buf, ptr, pairs[i]);	HS_FINALIZE(out, pcount, buf, ptr);	return out;}

Datumhstore_send(PG_FUNCTION_ARGS){	HStore	   *in = PG_GETARG_HS(0);	int			i;	int			count = HS_COUNT(in);	char	   *base = STRPTR(in);	HEntry	   *entries = ARRPTR(in);	StringInfoData buf;	pq_begintypsend(&buf);	pq_sendint(&buf, count, 4);	for (i = 0; i < count; i++)	{		int32		keylen = HS_KEYLEN(entries, i);		pq_sendint(&buf, keylen, 4);		pq_sendtext(&buf, HS_KEY(entries, base, i), keylen);		if (HS_VALISNULL(entries, i))		{			pq_sendint(&buf, -1, 4);		}		else		{			int32		vallen = HS_VALLEN(entries, i);			pq_sendint(&buf, vallen, 4);			pq_sendtext(&buf, HS_VAL(entries, base, i), vallen);		}	}	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));}

Datumgin_extract_tsvector(PG_FUNCTION_ARGS){	TSVector	vector = PG_GETARG_TSVECTOR(0);	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);	Datum	   *entries = NULL;	*nentries = vector->size;	if (vector->size > 0)	{		int			i;		WordEntry  *we = ARRPTR(vector);		entries = (Datum *) palloc(sizeof(Datum) * vector->size);		for (i = 0; i < vector->size; i++)		{			text	   *txt;			txt = cstring_to_text_with_len(STRPTR(vector) + we->pos, we->len);			entries[i] = PointerGetDatum(txt);			we++;		}	}	PG_FREE_IF_COPY(vector, 0);	PG_RETURN_POINTER(entries);}

ArrayType *intarray_concat_arrays(ArrayType *a, ArrayType *b){	ArrayType  *result;	int32		ac = ARRNELEMS(a);	int32		bc = ARRNELEMS(b);	CHECKARRVALID(a);	CHECKARRVALID(b);	result = new_intArrayType(ac + bc);	if (ac)		memcpy(ARRPTR(result), ARRPTR(a), ac * sizeof(int32));	if (bc)		memcpy(ARRPTR(result) + ac, ARRPTR(b), bc * sizeof(int32));	return result;}

Datumhstore_to_plperl(PG_FUNCTION_ARGS){	HStore	   *in = PG_GETARG_HS(0);	int			i;	int			count = HS_COUNT(in);	char	   *base = STRPTR(in);	HEntry	   *entries = ARRPTR(in);	HV		   *hv;	hv = newHV();	for (i = 0; i < count; i++)	{		const char *key;		SV		   *value;		key = pnstrdup(HS_KEY(entries, base, i), HS_KEYLEN(entries, i));		value = HS_VALISNULL(entries, i) ? newSV(0) : cstr2sv(pnstrdup(HS_VAL(entries, base, i), HS_VALLEN(entries, i)));		(void) hv_store(hv, key, strlen(key), value, 0);	}	return PointerGetDatum(newRV((SV *) hv));}

Datumboolop(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 HEntry *findkey(HStore * hs, char *key, int keylen){	HEntry	   *StopLow = ARRPTR(hs);	HEntry	   *StopHigh = StopLow + hs->size;	HEntry	   *StopMiddle;	int			difference;	char	   *base = STRPTR(hs);	while (StopLow < StopHigh)	{		StopMiddle = StopLow + (StopHigh - StopLow) / 2;		if (StopMiddle->keylen == keylen)			difference = strncmp(base + StopMiddle->pos, key, StopMiddle->keylen);		else			difference = (StopMiddle->keylen > keylen) ? 1 : -1;		if (difference == 0)			return StopMiddle;		else if (difference < 0)			StopLow = StopMiddle + 1;		else			StopHigh = StopMiddle;	}	return NULL;}

/* * Validity test for an old-format hstore. *	0 = not valid *	1 = valid but with "slop" in the length *	2 = exactly valid */static inthstoreValidOldFormat(HStore *hs){    int			count = hs->size_;    HOldEntry  *entries = (HOldEntry *) ARRPTR(hs);    int			vsize;    int			lastpos = 0;    int			i;    if (hs->size_ & HS_FLAG_NEWVERSION)        return 0;    /* New format uses an HEntry for key and another for value */    StaticAssertStmt(sizeof(HOldEntry) == 2 * sizeof(HEntry),                     "old hstore format is not upward-compatible");    if (count == 0)        return 2;    if (count > 0xFFFFFFF)        return 0;    if (CALCDATASIZE(count, 0) > VARSIZE(hs))        return 0;    if (entries[0].pos != 0)        return 0;    /* key length must be nondecreasing */    for (i = 1; i < count; ++i)    {        if (entries[i].keylen < entries[i - 1].keylen)            return 0;    }    /*     * entry position must be strictly increasing, except for the first entry     * (which can be ""=>"" and thus zero-length); and all entries must be     * properly contiguous     */    for (i = 0; i < count; ++i)    {        if (entries[i].pos != lastpos)            return 0;        lastpos += (entries[i].keylen                    + ((entries[i].valisnull) ? 0 : entries[i].vallen));    }    vsize = CALCDATASIZE(count, lastpos);    if (vsize > VARSIZE(hs))        return 0;    if (vsize != VARSIZE(hs))        return 1;    return 2;}

Datumghstore_compress(PG_FUNCTION_ARGS){	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);	GISTENTRY  *retval = entry;	if (entry->leafkey)	{		GISTTYPE   *res = (GISTTYPE *) palloc0(CALCGTSIZE(0));		HStore	   *val = DatumGetHStoreP(entry->key);		HEntry	   *hsent = ARRPTR(val);		char	   *ptr = STRPTR(val);		int			count = HS_COUNT(val);		int			i;		SET_VARSIZE(res, CALCGTSIZE(0));		for (i = 0; i < count; ++i)		{			int			h;			h = crc32_sz((char *) HSTORE_KEY(hsent, ptr, i),						 HSTORE_KEYLEN(hsent, i));			HASH(GETSIGN(res), h);			if (!HSTORE_VALISNULL(hsent, i))			{				h = crc32_sz((char *) HSTORE_VAL(hsent, ptr, i),							 HSTORE_VALLEN(hsent, i));				HASH(GETSIGN(res), h);			}		}		retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));		gistentryinit(*retval, PointerGetDatum(res),					  entry->rel, entry->page,					  entry->offset,					  FALSE);	}	else if (!ISALLTRUE(DatumGetPointer(entry->key)))	{		int32		i;		GISTTYPE   *res;		BITVECP		sign = GETSIGN(DatumGetPointer(entry->key));		LOOPBYTE		{			if ((sign[i] & 0xff) != 0xff)				PG_RETURN_POINTER(retval);		}		res = (GISTTYPE *) palloc(CALCGTSIZE(ALLISTRUE));		SET_VARSIZE(res, CALCGTSIZE(ALLISTRUE));		res->flag = ALLISTRUE;		retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));		gistentryinit(*retval, PointerGetDatum(res),					  entry->rel, entry->page,					  entry->offset,					  FALSE);	}

Datumtsvector2textarray(PG_FUNCTION_ARGS){	TSVector	ts = PG_GETARG_TSVECTOR(0);	ArrayType	*a;	Datum		*words;	int			i;	WordEntry	*wptr = ARRPTR(ts);	words = palloc( sizeof(Datum) * (ts->size+1) );	for(i=0; i<ts->size; i++)	{		text		*t = palloc(VARHDRSZ + wptr->len);		SET_VARSIZE(t, VARHDRSZ + wptr->len);		memcpy( VARDATA(t), STRPTR(ts) + wptr->pos, wptr->len);		words[i] = PointerGetDatum(t);			wptr++;	}	a = construct_array( words, ts->size,							TEXTOID, -1, false, 'i' );	PG_FREE_IF_COPY(ts, 0);	PG_RETURN_ARRAYTYPE_P(a);}

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

Datumhstore_slice_to_array(PG_FUNCTION_ARGS){    HStore	   *hs = PG_GETARG_HS(0);    HEntry	   *entries = ARRPTR(hs);    char	   *ptr = STRPTR(hs);    ArrayType  *key_array = PG_GETARG_ARRAYTYPE_P(1);    ArrayType  *aout;    Datum	   *key_datums;    bool	   *key_nulls;    Datum	   *out_datums;    bool	   *out_nulls;    int			key_count;    int			i;    deconstruct_array(key_array,                      TEXTOID, -1, false, 'i',                      &key_datums, &key_nulls, &key_count);    if (key_count == 0)    {        aout = construct_empty_array(TEXTOID);        PG_RETURN_POINTER(aout);    }    out_datums = palloc(sizeof(Datum) * key_count);    out_nulls = palloc(sizeof(bool) * key_count);    for (i = 0; i < key_count; ++i)    {        text	   *key = (text *) DatumGetPointer(key_datums[i]);        int			idx;        if (key_nulls[i])            idx = -1;        else            idx = hstoreFindKey(hs, NULL, VARDATA(key), VARSIZE(key) - VARHDRSZ);        if (idx < 0 || HS_VALISNULL(entries, idx))        {            out_nulls[i] = true;            out_datums[i] = (Datum) 0;        }        else        {            out_datums[i] = PointerGetDatum(                                cstring_to_text_with_len(HS_VAL(entries, ptr, idx),                                        HS_VALLEN(entries, idx)));            out_nulls[i] = false;        }    }    aout = construct_md_array(out_datums, out_nulls,                              ARR_NDIM(key_array),                              ARR_DIMS(key_array),                              ARR_LBOUND(key_array),                              TEXTOID, -1, false, 'i');    PG_RETURN_POINTER(aout);}

Datumskeys(PG_FUNCTION_ARGS){	FuncCallContext *funcctx;	AKStore    *st;	if (SRF_IS_FIRSTCALL())	{		HStore	   *hs = PG_GETARG_HS(0);		funcctx = SRF_FIRSTCALL_INIT();		setup_firstcall(funcctx, hs);		PG_FREE_IF_COPY(hs, 0);	}	funcctx = SRF_PERCALL_SETUP();	st = (AKStore *) funcctx->user_fctx;	if (st->i < st->hs->size)	{		HEntry	   *ptr = &(ARRPTR(st->hs)[st->i]);		text	   *item = (text *) palloc(VARHDRSZ + ptr->keylen);		SET_VARSIZE(item, VARHDRSZ + ptr->keylen);		memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen);		st->i++;		SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));	}	pfree(st->hs);	pfree(st);	SRF_RETURN_DONE(funcctx);}

ArrayType *intarray_add_elem(ArrayType *a, int32 elem){	ArrayType  *result;	int32	   *r;	int32		c;	CHECKARRVALID(a);	c = ARRNELEMS(a);	result = new_intArrayType(c + 1);	r = ARRPTR(result);	if (c > 0)		memcpy(r, ARRPTR(a), c * sizeof(int32));	r[c] = elem;	return result;}

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

/*** Allows the construction of a zero-volume cube from a float[]*/Datumcube_a_f8(PG_FUNCTION_ARGS){	ArrayType  *ur = PG_GETARG_ARRAYTYPE_P(0);	NDBOX	   *result;	int			i;	int			dim;	int			size;	double	   *dur;	if (array_contains_nulls(ur))		ereport(ERROR,				(errcode(ERRCODE_ARRAY_ELEMENT_ERROR),				 errmsg("cannot work with arrays containing NULLs")));	dim = ARRNELEMS(ur);	dur = ARRPTR(ur);	size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;	result = (NDBOX *) palloc0(size);	SET_VARSIZE(result, size);	result->dim = dim;	for (i = 0; i < dim; i++)	{		result->x[i] = dur[i];		result->x[i + dim] = dur[i];	}	PG_RETURN_NDBOX(result);}

Datumhstore_akeys(PG_FUNCTION_ARGS){    HStore	   *hs = PG_GETARG_HS(0);    Datum	   *d;    ArrayType  *a;    HEntry	   *entries = ARRPTR(hs);    char	   *base = STRPTR(hs);    int			count = HS_COUNT(hs);    int			i;    if (count == 0)    {        a = construct_empty_array(TEXTOID);        PG_RETURN_POINTER(a);    }    d = (Datum *) palloc(sizeof(Datum) * count);    for (i = 0; i < count; ++i)    {        text	   *item = cstring_to_text_with_len(HS_KEY(entries, base, i),                           HS_KEYLEN(entries, i));        d[i] = PointerGetDatum(item);    }    a = construct_array(d, count,                        TEXTOID, -1, false, 'i');    PG_RETURN_POINTER(a);}

Datumhstore_skeys(PG_FUNCTION_ARGS){    FuncCallContext *funcctx;    HStore	   *hs;    int			i;    if (SRF_IS_FIRSTCALL())    {        hs = PG_GETARG_HS(0);        funcctx = SRF_FIRSTCALL_INIT();        setup_firstcall(funcctx, hs, NULL);    }    funcctx = SRF_PERCALL_SETUP();    hs = (HStore *) funcctx->user_fctx;    i = funcctx->call_cntr;    if (i < HS_COUNT(hs))    {        HEntry	   *entries = ARRPTR(hs);        text	   *item;        item = cstring_to_text_with_len(HS_KEY(entries, STRPTR(hs), i),                                        HS_KEYLEN(entries, i));        SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));    }    SRF_RETURN_DONE(funcctx);}