RASTER_valueCount()

Datum RASTER_valueCount

(

PG_FUNCTION_ARGS

)

Definition at line 2410 of file rtpg_statistics.c.

References ovdump::band, genraster::count, rtpg_summarystats_arg_t::exclude_nodata_value, FALSE, PG_FUNCTION_INFO_V1(), POSTGIS_RT_DEBUGF, rtrowdump::raster, RASTER_valueCountCoverage(), rt_band_destroy(), rt_band_get_value_count(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_band(), rt_raster_get_num_bands(), TRUE, genraster::value, and VALUES_LENGTH.

                                          {
        FuncCallContext *funcctx;
        TupleDesc tupdesc;

        int i;
        rt_valuecount vcnts;
        rt_valuecount vcnts2;
        int call_cntr;
        int max_calls;

        /* first call of function */
        if (SRF_IS_FIRSTCALL()) {
                MemoryContext oldcontext;

                rt_pgraster *pgraster = NULL;
                rt_raster raster = NULL;
                rt_band band = NULL;
                int32_t bandindex = 0;
                int num_bands = 0;
                bool exclude_nodata_value = TRUE;
                double *search_values = NULL;
                uint32_t search_values_count = 0;
                double roundto = 0;
                uint32_t count;

                int j;
                int n;

                ArrayType *array;
                Oid etype;
                Datum *e;
                bool *nulls;
                int16 typlen;
                bool typbyval;
                char typalign;

                /* create a function context for cross-call persistence */
                funcctx = SRF_FIRSTCALL_INIT();

                /* switch to memory context appropriate for multiple function calls */
                oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

                /* pgraster is null, return nothing */
                if (PG_ARGISNULL(0)) {
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }
                pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));

                raster = rt_raster_deserialize(pgraster, FALSE);
                if (!raster) {
                        PG_FREE_IF_COPY(pgraster, 0);
                        MemoryContextSwitchTo(oldcontext);
                        elog(ERROR, "RASTER_valueCount: Cannot deserialize raster");
                        SRF_RETURN_DONE(funcctx);
                }

                /* band index is 1-based */
                bandindex = PG_GETARG_INT32(1);
                num_bands = rt_raster_get_num_bands(raster);
                if (bandindex < 1 || bandindex > num_bands) {
                        elog(NOTICE, "Invalid band index (must use 1-based). Returning NULL");
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }

                /* exclude_nodata_value flag */
                if (!PG_ARGISNULL(2))
                        exclude_nodata_value = PG_GETARG_BOOL(2);

                /* search values */
                if (!PG_ARGISNULL(3)) {
                        array = PG_GETARG_ARRAYTYPE_P(3);
                        etype = ARR_ELEMTYPE(array);
                        get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);

                        switch (etype) {
                                case FLOAT4OID:
                                case FLOAT8OID:
                                        break;
                                default:
                                        rt_raster_destroy(raster);
                                        PG_FREE_IF_COPY(pgraster, 0);
                                        MemoryContextSwitchTo(oldcontext);
                                        elog(ERROR, "RASTER_valueCount: Invalid data type for values");
                                        SRF_RETURN_DONE(funcctx);
                                        break;
                        }

                        deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
                                &nulls, &n);

                        search_values = palloc(sizeof(double) * n);
                        for (i = 0, j = 0; i < n; i++) {
                                if (nulls[i]) continue;

                                switch (etype) {
                                        case FLOAT4OID:
                                                search_values[j] = (double) DatumGetFloat4(e[i]);
                                                break;
                                        case FLOAT8OID:
                                                search_values[j] = (double) DatumGetFloat8(e[i]);
                                                break;
                                }

                                POSTGIS_RT_DEBUGF(5, "search_values[%d] = %f", j, search_values[j]);
                                j++;
                        }
                        search_values_count = j;

                        if (j < 1) {
                                pfree(search_values);
                                search_values = NULL;
                        }
                }

                /* roundto */
                if (!PG_ARGISNULL(4)) {
                        roundto = PG_GETARG_FLOAT8(4);
                        if (roundto < 0.) roundto = 0;
                }

                /* get band */
                band = rt_raster_get_band(raster, bandindex - 1);
                if (!band) {
                        elog(NOTICE, "Cannot find band at index %d. Returning NULL", bandindex);
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }

                /* get counts of values */
                vcnts = rt_band_get_value_count(band, (int) exclude_nodata_value, search_values, search_values_count, roundto, NULL, &count);
                rt_band_destroy(band);
                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);
                if (NULL == vcnts || !count) {
                        elog(NOTICE, "Cannot count the values for band at index %d", bandindex);
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }

                POSTGIS_RT_DEBUGF(3, "%d value counts returned", count);

                /* Store needed information */
                funcctx->user_fctx = vcnts;

                /* total number of tuples to be returned */
                funcctx->max_calls = count;

                /* Build a tuple descriptor for our result type */
                if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) {
                        ereport(ERROR, (
                                errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                errmsg(
                                        "function returning record called in context "
                                        "that cannot accept type record"
                                )
                        ));
                }

                BlessTupleDesc(tupdesc);
                funcctx->tuple_desc = tupdesc;

                MemoryContextSwitchTo(oldcontext);
        }

        /* stuff done on every call of the function */
        funcctx = SRF_PERCALL_SETUP();

        call_cntr = funcctx->call_cntr;
        max_calls = funcctx->max_calls;
        tupdesc = funcctx->tuple_desc;
        vcnts2 = funcctx->user_fctx;

        /* do when there is more left to send */
        if (call_cntr < max_calls) {
                Datum values[VALUES_LENGTH];
                bool nulls[VALUES_LENGTH];
                HeapTuple tuple;
                Datum result;

                POSTGIS_RT_DEBUGF(3, "Result %d", call_cntr);

                memset(nulls, FALSE, sizeof(bool) * VALUES_LENGTH);

                values[0] = Float8GetDatum(vcnts2[call_cntr].value);
                values[1] = UInt32GetDatum(vcnts2[call_cntr].count);
                values[2] = Float8GetDatum(vcnts2[call_cntr].percent);

                /* build a tuple */
                tuple = heap_form_tuple(tupdesc, values, nulls);

                /* make the tuple into a datum */
                result = HeapTupleGetDatum(tuple);

                SRF_RETURN_NEXT(funcctx, result);
        }
        /* do when there is no more left */
        else {
                pfree(vcnts2);
                SRF_RETURN_DONE(funcctx);
        }
}

Here is the call graph for this function: