gserialized_spgist_picksplit_nd()

PGDLLEXPORT Datum gserialized_spgist_picksplit_nd

(

PG_FUNCTION_ARGS

)

Definition at line 313 of file gserialized_spgist_nd.c.

{
        spgPickSplitIn *in = (spgPickSplitIn *)PG_GETARG_POINTER(0);
        spgPickSplitOut *out = (spgPickSplitOut *)PG_GETARG_POINTER(1);
        GIDX *centroid;
        float *lowXs, *highXs;
        int ndims, maxdims = -1, count[GIDX_MAX_DIM], median, dim, tuple;
 
        for (dim = 0; dim < GIDX_MAX_DIM; dim++)
                count[dim] = 0;
 
        lowXs = palloc(sizeof(float) * in->nTuples * GIDX_MAX_DIM),
        highXs = palloc(sizeof(float) * in->nTuples * GIDX_MAX_DIM);
 
        /* Calculate maxdims median of all ND coordinates */
        for (tuple = 0; tuple < in->nTuples; tuple++)
        {
                const GIDX *box = (const GIDX *)DatumGetPointer(in->datums[tuple]);
                ndims = GIDX_NDIMS(box);
                if (maxdims < ndims)
                        maxdims = ndims;
                for (dim = 0; dim < ndims; dim++)
                {
                        /* If the missing dimension was not padded with -+FLT_MAX */
                        if (GIDX_GET_MAX(box, dim) != FLT_MAX)
                        {
                                lowXs[dim * in->nTuples + count[dim]] = GIDX_GET_MIN(box, dim);
                                highXs[dim * in->nTuples + count[dim]] = GIDX_GET_MAX(box, dim);
                                count[dim]++;
                        }
                }
        }
 
        for (dim = 0; dim < maxdims; dim++)
        {
                qsort(&lowXs[dim * in->nTuples], count[dim], sizeof(float), compareFloats);
                qsort(&highXs[dim * in->nTuples], count[dim], sizeof(float), compareFloats);
        }
 
        centroid = (GIDX *)palloc(GIDX_SIZE(maxdims));
        SET_VARSIZE(centroid, GIDX_SIZE(maxdims));
 
        for (dim = 0; dim < maxdims; dim++)
        {
                median = count[dim] / 2;
                GIDX_SET_MIN(centroid, dim, lowXs[dim * in->nTuples + median]);
                GIDX_SET_MAX(centroid, dim, highXs[dim * in->nTuples + median]);
        }
 
        /* Fill the output */
        out->hasPrefix = true;
        out->prefixDatum = PointerGetDatum(gidx_copy(centroid));
 
        out->nNodes = 0x01 << (2 * maxdims);
        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 octants relative to
         * the "centroid" range
         */
        for (tuple = 0; tuple < in->nTuples; tuple++)
        {
                GIDX *box = (GIDX *)DatumGetPointer(in->datums[tuple]);
                uint16_t octant = getOctant(centroid, box);
 
                out->leafTupleDatums[tuple] = PointerGetDatum(box);
                out->mapTuplesToNodes[tuple] = octant;
        }
 
        pfree(lowXs);
        pfree(highXs);
 
        PG_RETURN_VOID();
}

References centroid(), compareFloats(), getOctant(), and gidx_copy().

Here is the call graph for this function: