gidx_brin_inclusion_add_value() [1/2]

static Datum gidx_brin_inclusion_add_value ( __attribute__((__unused__)) BrinDesc *  bdesc, BrinValues *  column, Datum  newval, bool  isnull, int  max_dims  )

static

Definition at line 66 of file brin_nd.c.

{
        char gboxmem[GIDX_MAX_SIZE];
        GIDX *gidx_geom, *gidx_key;
        int dims_geom, dims_key, i;
 
        Assert(max_dims <= GIDX_MAX_DIM);
 
        /*
         * If the new value is null, we record that we saw it if it's the first
         * one; otherwise, there's nothing to do.
         */
        if (isnull)
        {
                if (column->bv_hasnulls)
                        PG_RETURN_BOOL(false);
 
                column->bv_hasnulls = true;
                PG_RETURN_BOOL(true);
        }
 
        /*
         * No need for further processing if the block range is already initialized
         * and is marked as containing unmergeable values.
         */
        if (!column->bv_allnulls &&
                        DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE]))
                PG_RETURN_BOOL(false);
 
        /* create a new GIDX in stack memory, maximum dimensions */
        gidx_geom = (GIDX *) gboxmem;
 
        /*
         * check other cases where it is not possible to retrieve a box
         */
        if (gserialized_datum_get_gidx_p(newval, gidx_geom) == LW_FAILURE)
        {
                /*
                 * Empty entries have to be supported in the opclass: test the passed
                 * new value for emptiness; if it returns true, we need to set the
                 * "contains empty" flag in the element (unless already set).
                 */
                if (is_gserialized_from_datum_empty(newval))
                {
                        if (!DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]))
                        {
                                column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true);
                                PG_RETURN_BOOL(true);
                        }
 
                        PG_RETURN_BOOL(false);
                } else
                {
                        /*
                         * in case the entry is not empty and it is not possible to
                         * retrieve a box, raise an error
                         */
                        elog(ERROR, "Error while extracting the gidx from the geom");
                }
        }
 
        /* Get the actual dimension of the geometry */
        dims_geom = GIDX_NDIMS(gidx_geom);
 
        /* if the recorded value is null, we just need to store the GIDX */
        if (column->bv_allnulls)
        {
                /*
                 * It's not safe to summarize geometries of different number of
                 * dimensions in the same range.  We therefore fix the number of
                 * dimension for this range by storing the bounding box of the first
                 * geometry found as is, being careful not to store more dimension than
                 * defined in the opclass.
                 */
                if (dims_geom > max_dims)
                {
                        /*
                         * Diminush the varsize to only store the maximum number of
                         * dimensions allowed by the opclass
                         */
                        SET_VARSIZE(gidx_geom, VARHDRSZ + max_dims * 2 * sizeof(float));
                        dims_geom = max_dims;
                }
 
                column->bv_values[INCLUSION_UNION] = datumCopy((Datum) gidx_geom, false,
                                GIDX_SIZE(dims_geom));
                column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(false);
                column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(false);
                column->bv_allnulls = false;
                PG_RETURN_BOOL(true);
        }
 
        gidx_key = (GIDX *) column->bv_values[INCLUSION_UNION];
        dims_key = GIDX_NDIMS(gidx_key);
 
        /*
         * Mark the datum as unmergeable if its number of dimension is not the same
         * as the one stored in the key of the current range
         */
        if (dims_key != dims_geom)
        {
                column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
                PG_RETURN_BOOL(true);
        }
 
        /* Check if the stored bounding box already contains the geometry's one */
        if (gidx_contains(gidx_key, gidx_geom))
                        PG_RETURN_BOOL(false);
 
        /*
         * Otherwise, we need to enlarge the stored GIDX to make it contains the
         * current geometry.  As we store a GIDX with a fixed number of dimensions,
         * we just need adjust min and max
         */
        for ( i = 0; i < dims_key; i++ )
        {
                /* Adjust minimums */
                GIDX_SET_MIN(gidx_key, i,
                                Min(GIDX_GET_MIN(gidx_key,i),GIDX_GET_MIN(gidx_geom,i)));
                /* Adjust maximums */
                GIDX_SET_MAX(gidx_key, i,
                                Max(GIDX_GET_MAX(gidx_key,i),GIDX_GET_MAX(gidx_geom,i)));
        }
 
        PG_RETURN_BOOL(true);
}

References gidx_contains(), INCLUSION_CONTAINS_EMPTY, INCLUSION_UNION, INCLUSION_UNMERGEABLE, is_gserialized_from_datum_empty(), and LW_FAILURE.

Here is the call graph for this function: