contrib/btree_gist/btree_utils_num.c - cloudberry - Git at Google

 /*
  * contrib/btree_gist/btree_utils_num.c
  */
 #include "postgres.h"

 #include "btree_gist.h"
 #include "btree_utils_num.h"
 #include "utils/cash.h"
 #include "utils/date.h"
 #include "utils/timestamp.h"


 GISTENTRY *
 gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo)
 {
 	GISTENTRY  *retval;

 	if (entry->leafkey)
 	{
 		union
 		{
 			bool		bo;
 			int16		i2;
 			int32		i4;
 			int64		i8;
 			float4		f4;
 			float8		f8;
 			DateADT		dt;
 			TimeADT		tm;
 			Timestamp	ts;
 			Cash		ch;
 		}			v;

 		GBT_NUMKEY *r = (GBT_NUMKEY *) palloc0(tinfo->indexsize);
 		void	   *leaf = NULL;

 		switch (tinfo->t)
 		{
 			case gbt_t_bool:
 				v.bo = DatumGetBool(entry->key);
 				leaf = &v.bo;
 				break;
 			case gbt_t_int2:
 				v.i2 = DatumGetInt16(entry->key);
 				leaf = &v.i2;
 				break;
 			case gbt_t_int4:
 				v.i4 = DatumGetInt32(entry->key);
 				leaf = &v.i4;
 				break;
 			case gbt_t_int8:
 				v.i8 = DatumGetInt64(entry->key);
 				leaf = &v.i8;
 				break;
 			case gbt_t_oid:
 			case gbt_t_enum:
 				v.i4 = DatumGetObjectId(entry->key);
 				leaf = &v.i4;
 				break;
 			case gbt_t_float4:
 				v.f4 = DatumGetFloat4(entry->key);
 				leaf = &v.f4;
 				break;
 			case gbt_t_float8:
 				v.f8 = DatumGetFloat8(entry->key);
 				leaf = &v.f8;
 				break;
 			case gbt_t_date:
 				v.dt = DatumGetDateADT(entry->key);
 				leaf = &v.dt;
 				break;
 			case gbt_t_time:
 				v.tm = DatumGetTimeADT(entry->key);
 				leaf = &v.tm;
 				break;
 			case gbt_t_ts:
 				v.ts = DatumGetTimestamp(entry->key);
 				leaf = &v.ts;
 				break;
 			case gbt_t_cash:
 				v.ch = DatumGetCash(entry->key);
 				leaf = &v.ch;
 				break;
 			default:
 				leaf = DatumGetPointer(entry->key);
 		}

 		Assert(tinfo->indexsize >= 2 * tinfo->size);

 		memcpy(&r[0], leaf, tinfo->size);
 		memcpy(&r[tinfo->size], leaf, tinfo->size);
 		retval = palloc(sizeof(GISTENTRY));
 		gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
 					  entry->offset, false);
 	}
 	else
 		retval = entry;

 	return retval;
 }

 /*
  * Convert a compressed leaf item back to the original type, for index-only
  * scans.
  */
 GISTENTRY *
 gbt_num_fetch(GISTENTRY *entry, const gbtree_ninfo *tinfo)
 {
 	GISTENTRY  *retval;
 	Datum		datum;

 	Assert(tinfo->indexsize >= 2 * tinfo->size);

 	/*
 	 * Get the original Datum from the stored datum. On leaf entries, the
 	 * lower and upper bound are the same. We just grab the lower bound and
 	 * return it.
 	 */
 	switch (tinfo->t)
 	{
 		case gbt_t_bool:
 			datum = BoolGetDatum(*(bool *) entry->key);
 			break;
 		case gbt_t_int2:
 			datum = Int16GetDatum(*(int16 *) entry->key);
 			break;
 		case gbt_t_int4:
 			datum = Int32GetDatum(*(int32 *) entry->key);
 			break;
 		case gbt_t_int8:
 			datum = Int64GetDatum(*(int64 *) entry->key);
 			break;
 		case gbt_t_oid:
 		case gbt_t_enum:
 			datum = ObjectIdGetDatum(*(Oid *) entry->key);
 			break;
 		case gbt_t_float4:
 			datum = Float4GetDatum(*(float4 *) entry->key);
 			break;
 		case gbt_t_float8:
 			datum = Float8GetDatum(*(float8 *) entry->key);
 			break;
 		case gbt_t_date:
 			datum = DateADTGetDatum(*(DateADT *) entry->key);
 			break;
 		case gbt_t_time:
 			datum = TimeADTGetDatum(*(TimeADT *) entry->key);
 			break;
 		case gbt_t_ts:
 			datum = TimestampGetDatum(*(Timestamp *) entry->key);
 			break;
 		case gbt_t_cash:
 			datum = CashGetDatum(*(Cash *) entry->key);
 			break;
 		default:
 			datum = entry->key;
 	}

 	retval = palloc(sizeof(GISTENTRY));
 	gistentryinit(*retval, datum, entry->rel, entry->page, entry->offset,
 				  false);
 	return retval;
 }


 /*
 ** The GiST union method for numerical values
 */

 void *
 gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
 {
 	int			i,
 				numranges;
 	GBT_NUMKEY *cur;
 	GBT_NUMKEY_R o,
 				c;

 	numranges = entryvec->n;
 	cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key));


 	o.lower = &((GBT_NUMKEY *) out)[0];
 	o.upper = &((GBT_NUMKEY *) out)[tinfo->size];

 	memcpy(out, cur, 2 * tinfo->size);

 	for (i = 1; i < numranges; i++)
 	{
 		cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
 		c.lower = &cur[0];
 		c.upper = &cur[tinfo->size];
 		/* if out->lower > cur->lower, adopt cur as lower */
 		if (tinfo->f_gt(o.lower, c.lower, flinfo))
 			memcpy(unconstify(GBT_NUMKEY *, o.lower), c.lower, tinfo->size);
 		/* if out->upper < cur->upper, adopt cur as upper */
 		if (tinfo->f_lt(o.upper, c.upper, flinfo))
 			memcpy(unconstify(GBT_NUMKEY *, o.upper), c.upper, tinfo->size);
 	}

 	return out;
 }


 /*
 ** The GiST same method for numerical values
 */

 bool
 gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
 {
 	GBT_NUMKEY_R b1,
 				b2;

 	b1.lower = &(a[0]);
 	b1.upper = &(a[tinfo->size]);
 	b2.lower = &(b[0]);
 	b2.upper = &(b[tinfo->size]);

 	return (tinfo->f_eq(b1.lower, b2.lower, flinfo) &&
 			tinfo->f_eq(b1.upper, b2.upper, flinfo));
 }


 void
 gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
 {
 	GBT_NUMKEY_R rd;

 	rd.lower = &e[0];
 	rd.upper = &e[tinfo->size];

 	if (!DatumGetPointer(*u))
 	{
 		*u = PointerGetDatum(palloc0(tinfo->indexsize));
 		memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[0]), rd.lower, tinfo->size);
 		memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]), rd.upper, tinfo->size);
 	}
 	else
 	{
 		GBT_NUMKEY_R ur;

 		ur.lower = &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]);
 		ur.upper = &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]);
 		if (tinfo->f_gt(ur.lower, rd.lower, flinfo))
 			memcpy(unconstify(GBT_NUMKEY *, ur.lower), rd.lower, tinfo->size);
 		if (tinfo->f_lt(ur.upper, rd.upper, flinfo))
 			memcpy(unconstify(GBT_NUMKEY *, ur.upper), rd.upper, tinfo->size);
 	}
 }


 /*
  * The GiST consistent method
  *
  * Note: we currently assume that no datatypes that use this routine are
  * collation-aware; so we don't bother passing collation through.
  */
 bool
 gbt_num_consistent(const GBT_NUMKEY_R *key,
 				   const void *query,
 				   const StrategyNumber *strategy,
 				   bool is_leaf,
 				   const gbtree_ninfo *tinfo,
 				   FmgrInfo *flinfo)
 {
 	bool		retval;

 	switch (*strategy)
 	{
 		case BTLessEqualStrategyNumber:
 			retval = tinfo->f_ge(query, key->lower, flinfo);
 			break;
 		case BTLessStrategyNumber:
 			if (is_leaf)
 				retval = tinfo->f_gt(query, key->lower, flinfo);
 			else
 				retval = tinfo->f_ge(query, key->lower, flinfo);
 			break;
 		case BTEqualStrategyNumber:
 			if (is_leaf)
 				retval = tinfo->f_eq(query, key->lower, flinfo);
 			else
 				retval = (tinfo->f_le(key->lower, query, flinfo) &&
 						  tinfo->f_le(query, key->upper, flinfo));
 			break;
 		case BTGreaterStrategyNumber:
 			if (is_leaf)
 				retval = tinfo->f_lt(query, key->upper, flinfo);
 			else
 				retval = tinfo->f_le(query, key->upper, flinfo);
 			break;
 		case BTGreaterEqualStrategyNumber:
 			retval = tinfo->f_le(query, key->upper, flinfo);
 			break;
 		case BtreeGistNotEqualStrategyNumber:
 			retval = (!(tinfo->f_eq(query, key->lower, flinfo) &&
 						tinfo->f_eq(query, key->upper, flinfo)));
 			break;
 		default:
 			retval = false;
 	}

 	return retval;
 }


 /*
 ** The GiST distance method (for KNN-Gist)
 */

 float8
 gbt_num_distance(const GBT_NUMKEY_R *key,
 				 const void *query,
 				 bool is_leaf,
 				 const gbtree_ninfo *tinfo,
 				 FmgrInfo *flinfo)
 {
 	float8		retval;

 	if (tinfo->f_dist == NULL)
 		elog(ERROR, "KNN search is not supported for btree_gist type %d",
 			 (int) tinfo->t);
 	if (tinfo->f_le(query, key->lower, flinfo))
 		retval = tinfo->f_dist(query, key->lower, flinfo);
 	else if (tinfo->f_ge(query, key->upper, flinfo))
 		retval = tinfo->f_dist(query, key->upper, flinfo);
 	else
 		retval = 0.0;

 	return retval;
 }


 GIST_SPLITVEC *
 gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
 				  const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
 {
 	OffsetNumber i,
 				maxoff = entryvec->n - 1;
 	Nsrt	   *arr;
 	int			nbytes;

 	arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt));
 	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
 	v->spl_left = (OffsetNumber *) palloc(nbytes);
 	v->spl_right = (OffsetNumber *) palloc(nbytes);
 	v->spl_ldatum = PointerGetDatum(0);
 	v->spl_rdatum = PointerGetDatum(0);
 	v->spl_nleft = 0;
 	v->spl_nright = 0;

 	/* Sort entries */

 	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
 	{
 		arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
 		arr[i].i = i;
 	}
 	qsort_arg(&arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, flinfo);

 	/* We do simply create two parts */

 	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
 	{
 		if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
 		{
 			gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo, flinfo);
 			v->spl_left[v->spl_nleft] = arr[i].i;
 			v->spl_nleft++;
 		}
 		else
 		{
 			gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo, flinfo);
 			v->spl_right[v->spl_nright] = arr[i].i;
 			v->spl_nright++;
 		}
 	}

 	return v;
 }
	/*
	* contrib/btree_gist/btree_utils_num.c
	*/
	#include "postgres.h"

	#include "btree_gist.h"
	#include "btree_utils_num.h"
	#include "utils/cash.h"
	#include "utils/date.h"
	#include "utils/timestamp.h"


	GISTENTRY *
	gbt_num_compress(GISTENTRY entry, const gbtree_ninfo tinfo)
	{
	GISTENTRY *retval;

	if (entry->leafkey)
	{
	union
	{
	bool bo;
	int16 i2;
	int32 i4;
	int64 i8;
	float4 f4;
	float8 f8;
	DateADT dt;
	TimeADT tm;
	Timestamp ts;
	Cash ch;
	} v;

	GBT_NUMKEY r = (GBT_NUMKEY ) palloc0(tinfo->indexsize);
	void *leaf = NULL;

	switch (tinfo->t)
	{
	case gbt_t_bool:
	v.bo = DatumGetBool(entry->key);
	leaf = &v.bo;
	break;
	case gbt_t_int2:
	v.i2 = DatumGetInt16(entry->key);
	leaf = &v.i2;
	break;
	case gbt_t_int4:
	v.i4 = DatumGetInt32(entry->key);
	leaf = &v.i4;
	break;
	case gbt_t_int8:
	v.i8 = DatumGetInt64(entry->key);
	leaf = &v.i8;
	break;
	case gbt_t_oid:
	case gbt_t_enum:
	v.i4 = DatumGetObjectId(entry->key);
	leaf = &v.i4;
	break;
	case gbt_t_float4:
	v.f4 = DatumGetFloat4(entry->key);
	leaf = &v.f4;
	break;
	case gbt_t_float8:
	v.f8 = DatumGetFloat8(entry->key);
	leaf = &v.f8;
	break;
	case gbt_t_date:
	v.dt = DatumGetDateADT(entry->key);
	leaf = &v.dt;
	break;
	case gbt_t_time:
	v.tm = DatumGetTimeADT(entry->key);
	leaf = &v.tm;
	break;
	case gbt_t_ts:
	v.ts = DatumGetTimestamp(entry->key);
	leaf = &v.ts;
	break;
	case gbt_t_cash:
	v.ch = DatumGetCash(entry->key);
	leaf = &v.ch;
	break;
	default:
	leaf = DatumGetPointer(entry->key);
	}

	Assert(tinfo->indexsize >= 2 * tinfo->size);

	memcpy(&r[0], leaf, tinfo->size);
	memcpy(&r[tinfo->size], leaf, tinfo->size);
	retval = palloc(sizeof(GISTENTRY));
	gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
	entry->offset, false);
	}
	else
	retval = entry;

	return retval;
	}

	/*
	* Convert a compressed leaf item back to the original type, for index-only
	* scans.
	*/
	GISTENTRY *
	gbt_num_fetch(GISTENTRY entry, const gbtree_ninfo tinfo)
	{
	GISTENTRY *retval;
	Datum datum;

	Assert(tinfo->indexsize >= 2 * tinfo->size);

	/*
	* Get the original Datum from the stored datum. On leaf entries, the
	* lower and upper bound are the same. We just grab the lower bound and
	* return it.
	*/
	switch (tinfo->t)
	{
	case gbt_t_bool:
	datum = BoolGetDatum((bool ) entry->key);
	break;
	case gbt_t_int2:
	datum = Int16GetDatum((int16 ) entry->key);
	break;
	case gbt_t_int4:
	datum = Int32GetDatum((int32 ) entry->key);
	break;
	case gbt_t_int8:
	datum = Int64GetDatum((int64 ) entry->key);
	break;
	case gbt_t_oid:
	case gbt_t_enum:
	datum = ObjectIdGetDatum((Oid ) entry->key);
	break;
	case gbt_t_float4:
	datum = Float4GetDatum((float4 ) entry->key);
	break;
	case gbt_t_float8:
	datum = Float8GetDatum((float8 ) entry->key);
	break;
	case gbt_t_date:
	datum = DateADTGetDatum((DateADT ) entry->key);
	break;
	case gbt_t_time:
	datum = TimeADTGetDatum((TimeADT ) entry->key);
	break;
	case gbt_t_ts:
	datum = TimestampGetDatum((Timestamp ) entry->key);
	break;
	case gbt_t_cash:
	datum = CashGetDatum((Cash ) entry->key);
	break;
	default:
	datum = entry->key;
	}

	retval = palloc(sizeof(GISTENTRY));
	gistentryinit(*retval, datum, entry->rel, entry->page, entry->offset,
	false);
	return retval;
	}



	/*
	** The GiST union method for numerical values
	*/

	void *
	gbt_num_union(GBT_NUMKEY out, const GistEntryVector entryvec, const gbtree_ninfo tinfo, FmgrInfo flinfo)
	{
	int i,
	numranges;
	GBT_NUMKEY *cur;
	GBT_NUMKEY_R o,
	c;

	numranges = entryvec->n;
	cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key));


	o.lower = &((GBT_NUMKEY *) out)[0];
	o.upper = &((GBT_NUMKEY *) out)[tinfo->size];

	memcpy(out, cur, 2 * tinfo->size);

	for (i = 1; i < numranges; i++)
	{
	cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
	c.lower = &cur[0];
	c.upper = &cur[tinfo->size];
	/* if out->lower > cur->lower, adopt cur as lower */
	if (tinfo->f_gt(o.lower, c.lower, flinfo))
	memcpy(unconstify(GBT_NUMKEY *, o.lower), c.lower, tinfo->size);
	/* if out->upper < cur->upper, adopt cur as upper */
	if (tinfo->f_lt(o.upper, c.upper, flinfo))
	memcpy(unconstify(GBT_NUMKEY *, o.upper), c.upper, tinfo->size);
	}

	return out;
	}



	/*
	** The GiST same method for numerical values
	*/

	bool
	gbt_num_same(const GBT_NUMKEY a, const GBT_NUMKEY b, const gbtree_ninfo tinfo, FmgrInfo flinfo)
	{
	GBT_NUMKEY_R b1,
	b2;

	b1.lower = &(a[0]);
	b1.upper = &(a[tinfo->size]);
	b2.lower = &(b[0]);
	b2.upper = &(b[tinfo->size]);

	return (tinfo->f_eq(b1.lower, b2.lower, flinfo) &&
	tinfo->f_eq(b1.upper, b2.upper, flinfo));
	}


	void
	gbt_num_bin_union(Datum u, GBT_NUMKEY e, const gbtree_ninfo tinfo, FmgrInfo flinfo)
	{
	GBT_NUMKEY_R rd;

	rd.lower = &e[0];
	rd.upper = &e[tinfo->size];

	if (!DatumGetPointer(*u))
	{
	*u = PointerGetDatum(palloc0(tinfo->indexsize));
	memcpy(&(((GBT_NUMKEY ) DatumGetPointer(u))[0]), rd.lower, tinfo->size);
	memcpy(&(((GBT_NUMKEY ) DatumGetPointer(u))[tinfo->size]), rd.upper, tinfo->size);
	}
	else
	{
	GBT_NUMKEY_R ur;

	ur.lower = &(((GBT_NUMKEY ) DatumGetPointer(u))[0]);
	ur.upper = &(((GBT_NUMKEY ) DatumGetPointer(u))[tinfo->size]);
	if (tinfo->f_gt(ur.lower, rd.lower, flinfo))
	memcpy(unconstify(GBT_NUMKEY *, ur.lower), rd.lower, tinfo->size);
	if (tinfo->f_lt(ur.upper, rd.upper, flinfo))
	memcpy(unconstify(GBT_NUMKEY *, ur.upper), rd.upper, tinfo->size);
	}
	}



	/*
	* The GiST consistent method
	*
	* Note: we currently assume that no datatypes that use this routine are
	* collation-aware; so we don't bother passing collation through.
	*/
	bool
	gbt_num_consistent(const GBT_NUMKEY_R *key,
	const void *query,
	const StrategyNumber *strategy,
	bool is_leaf,
	const gbtree_ninfo *tinfo,
	FmgrInfo *flinfo)
	{
	bool retval;

	switch (*strategy)
	{
	case BTLessEqualStrategyNumber:
	retval = tinfo->f_ge(query, key->lower, flinfo);
	break;
	case BTLessStrategyNumber:
	if (is_leaf)
	retval = tinfo->f_gt(query, key->lower, flinfo);
	else
	retval = tinfo->f_ge(query, key->lower, flinfo);
	break;
	case BTEqualStrategyNumber:
	if (is_leaf)
	retval = tinfo->f_eq(query, key->lower, flinfo);
	else
	retval = (tinfo->f_le(key->lower, query, flinfo) &&
	tinfo->f_le(query, key->upper, flinfo));
	break;
	case BTGreaterStrategyNumber:
	if (is_leaf)
	retval = tinfo->f_lt(query, key->upper, flinfo);
	else
	retval = tinfo->f_le(query, key->upper, flinfo);
	break;
	case BTGreaterEqualStrategyNumber:
	retval = tinfo->f_le(query, key->upper, flinfo);
	break;
	case BtreeGistNotEqualStrategyNumber:
	retval = (!(tinfo->f_eq(query, key->lower, flinfo) &&
	tinfo->f_eq(query, key->upper, flinfo)));
	break;
	default:
	retval = false;
	}

	return retval;
	}


	/*
	** The GiST distance method (for KNN-Gist)
	*/

	float8
	gbt_num_distance(const GBT_NUMKEY_R *key,
	const void *query,
	bool is_leaf,
	const gbtree_ninfo *tinfo,
	FmgrInfo *flinfo)
	{
	float8 retval;

	if (tinfo->f_dist == NULL)
	elog(ERROR, "KNN search is not supported for btree_gist type %d",
	(int) tinfo->t);
	if (tinfo->f_le(query, key->lower, flinfo))
	retval = tinfo->f_dist(query, key->lower, flinfo);
	else if (tinfo->f_ge(query, key->upper, flinfo))
	retval = tinfo->f_dist(query, key->upper, flinfo);
	else
	retval = 0.0;

	return retval;
	}


	GIST_SPLITVEC *
	gbt_num_picksplit(const GistEntryVector entryvec, GIST_SPLITVEC v,
	const gbtree_ninfo tinfo, FmgrInfo flinfo)
	{
	OffsetNumber i,
	maxoff = entryvec->n - 1;
	Nsrt *arr;
	int nbytes;

	arr = (Nsrt ) palloc((maxoff + 1) sizeof(Nsrt));
	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
	v->spl_left = (OffsetNumber *) palloc(nbytes);
	v->spl_right = (OffsetNumber *) palloc(nbytes);
	v->spl_ldatum = PointerGetDatum(0);
	v->spl_rdatum = PointerGetDatum(0);
	v->spl_nleft = 0;
	v->spl_nright = 0;

	/* Sort entries */

	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
	{
	arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
	arr[i].i = i;
	}
	qsort_arg(&arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, flinfo);

	/* We do simply create two parts */

	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
	{
	if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
	{
	gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo, flinfo);
	v->spl_left[v->spl_nleft] = arr[i].i;
	v->spl_nleft++;
	}
	else
	{
	gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo, flinfo);
	v->spl_right[v->spl_nright] = arr[i].i;
	v->spl_nright++;
	}
	}

	return v;
	}