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