/*
* rangesel -- restriction selectivity for range operators
*/
Datum
rangesel(PG_FUNCTION_ARGS)
{
PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
Oid operator = PG_GETARG_OID(1);
List *args = (List *) PG_GETARG_POINTER(2);
int varRelid = PG_GETARG_INT32(3);
VariableStatData vardata;
Node *other;
bool varonleft;
Selectivity selec;
TypeCacheEntry *typcache = NULL;
RangeType *constrange = NULL;
/*
* If expression is not (variable op something) or (something op
* variable), then punt and return a default estimate.
*/
if (!get_restriction_variable(root, args, varRelid,
&vardata, &other, &varonleft))
PG_RETURN_FLOAT8(default_range_selectivity(operator));
/*
* Can't do anything useful if the something is not a constant, either.
*/
if (!IsA(other, Const))
{
ReleaseVariableStats(vardata);
PG_RETURN_FLOAT8(default_range_selectivity(operator));
}
/*
* All the range operators are strict, so we can cope with a NULL constant
* right away.
*/
if (((Const *) other)->constisnull)
{
ReleaseVariableStats(vardata);
PG_RETURN_FLOAT8(0.0);
}
/*
* If var is on the right, commute the operator, so that we can assume the
* var is on the left in what follows.
*/
if (!varonleft)
{
/* we have other Op var, commute to make var Op other */
operator = get_commutator(operator);
if (!operator)
{
/* Use default selectivity (should we raise an error instead?) */
ReleaseVariableStats(vardata);
PG_RETURN_FLOAT8(default_range_selectivity(operator));
}
}
/*
* OK, there's a Var and a Const we're dealing with here. We need the
* Const to be of same range type as the column, else we can't do anything
* useful. (Such cases will likely fail at runtime, but here we'd rather
* just return a default estimate.)
*
* If the operator is "range @> element", the constant should be of the
* element type of the range column. Convert it to a range that includes
* only that single point, so that we don't need special handling for that
* in what follows.
*/
if (operator == OID_RANGE_CONTAINS_ELEM_OP)
{
typcache = range_get_typcache(fcinfo, vardata.vartype);
if (((Const *) other)->consttype == typcache->rngelemtype->type_id)
{
RangeBound lower,
upper;
lower.inclusive = true;
lower.val = ((Const *) other)->constvalue;
lower.infinite = false;
lower.lower = true;
upper.inclusive = true;
upper.val = ((Const *) other)->constvalue;
upper.infinite = false;
upper.lower = false;
constrange = range_serialize(typcache, &lower, &upper, false);
}
}
else if (operator == OID_RANGE_ELEM_CONTAINED_OP)
{
/*
* Here, the Var is the elem, not the range. For now we just punt and
* return the default estimate. In future we could disassemble the
* range constant and apply scalarineqsel ...
*/
}
else if (((Const *) other)->consttype == vardata.vartype)
{
/* Both sides are the same range type */
typcache = range_get_typcache(fcinfo, vardata.vartype);
constrange = DatumGetRangeType(((Const *) other)->constvalue);
}
/*
* If we got a valid constant on one side of the operator, proceed to
* estimate using statistics. Otherwise punt and return a default constant
* estimate. Note that calc_rangesel need not handle
* OID_RANGE_ELEM_CONTAINED_OP.
*/
if (constrange)
selec = calc_rangesel(typcache, &vardata, constrange, operator);
else
selec = default_range_selectivity(operator);
ReleaseVariableStats(vardata);
CLAMP_PROBABILITY(selec);
PG_RETURN_FLOAT8((float8) selec);
}
/*
* Picksplit SP-GiST function: split ranges into nodes. Select "centroid"
* range and distribute ranges according to quadrants.
*/
Datum
spg_range_quad_picksplit(PG_FUNCTION_ARGS)
{
spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
int i;
int j;
int nonEmptyCount;
RangeType *centroid;
bool empty;
TypeCacheEntry *typcache;
/* Use the median values of lower and upper bounds as the centroid range */
RangeBound *lowerBounds,
*upperBounds;
typcache = range_get_typcache(fcinfo,
RangeTypeGetOid(DatumGetRangeType(in->datums[0])));
/* Allocate memory for bounds */
lowerBounds = palloc(sizeof(RangeBound) * in->nTuples);
upperBounds = palloc(sizeof(RangeBound) * in->nTuples);
j = 0;
/* Deserialize bounds of ranges, count non-empty ranges */
for (i = 0; i < in->nTuples; i++)
{
range_deserialize(typcache, DatumGetRangeType(in->datums[i]),
&lowerBounds[j], &upperBounds[j], &empty);
if (!empty)
j++;
}
nonEmptyCount = j;
/*
* All the ranges are empty. The best we can do is to construct an inner
* node with no centroid, and put all ranges into node 0. If non-empty
* ranges are added later, they will be routed to node 1.
*/
if (nonEmptyCount == 0)
{
out->nNodes = 2;
out->hasPrefix = false;
/* Prefix is empty */
out->prefixDatum = PointerGetDatum(NULL);
out->nodeLabels = NULL;
out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
/* Place all ranges into node 0 */
for (i = 0; i < in->nTuples; i++)
{
RangeType *range = DatumGetRangeType(in->datums[i]);
out->leafTupleDatums[i] = RangeTypeGetDatum(range);
out->mapTuplesToNodes[i] = 0;
}
PG_RETURN_VOID();
}
/* Sort range bounds in order to find medians */
qsort_arg(lowerBounds, nonEmptyCount, sizeof(RangeBound),
bound_cmp, typcache);
qsort_arg(upperBounds, nonEmptyCount, sizeof(RangeBound),
bound_cmp, typcache);
/* Construct "centroid" range from medians of lower and upper bounds */
centroid = range_serialize(typcache, &lowerBounds[nonEmptyCount / 2],
&upperBounds[nonEmptyCount / 2], false);
out->hasPrefix = true;
out->prefixDatum = RangeTypeGetDatum(centroid);
/* Create node for empty ranges only if it is a root node */
out->nNodes = (in->level == 0) ? 5 : 4;
out->nodeLabels = NULL; /* we don't need node labels */
out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
/*
* Assign ranges to corresponding nodes according to quadrants relative to
* "centroid" range.
*/
for (i = 0; i < in->nTuples; i++)
{
RangeType *range = DatumGetRangeType(in->datums[i]);
int16 quadrant = getQuadrant(typcache, centroid, range);
out->leafTupleDatums[i] = RangeTypeGetDatum(range);
out->mapTuplesToNodes[i] = quadrant - 1;
}
PG_RETURN_VOID();
}
