RASTER_summaryStatsCoverage()

Datum RASTER_summaryStatsCoverage

(

PG_FUNCTION_ARGS

)

Definition at line 198 of file rtpg_statistics.c.

References ovdump::band, rt_bandstats_t::count, FALSE, FLT_EQ, rt_bandstats_t::max, rt_bandstats_t::mean, rt_bandstats_t::min, rtrowdump::raster, rt_band_destroy(), rt_band_get_summary_stats(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_band(), rt_raster_get_num_bands(), rt_bandstats_t::sample, rt_bandstats_t::sorted, rtgdalraster::sql, rt_bandstats_t::stddev, rt_bandstats_t::sum, TRUE, rt_bandstats_t::values, and VALUES_LENGTH.

Referenced by RASTER_summaryStats().

{
        text *tablenametext = NULL;
        char *tablename = NULL;
        text *colnametext = NULL;
        char *colname = NULL;
        int32_t bandindex = 1;
        bool exclude_nodata_value = TRUE;
        double sample = 0;

        int len = 0;
        char *sql = NULL;
        int spi_result;
        Portal portal;
        TupleDesc tupdesc;
        SPITupleTable *tuptable = NULL;
        HeapTuple tuple;
        Datum datum;
        bool isNull = FALSE;

        rt_pgraster *pgraster = NULL;
        rt_raster raster = NULL;
        rt_band band = NULL;
        int num_bands = 0;
        uint64_t cK = 0;
        double cM = 0;
        double cQ = 0;
        rt_bandstats stats = NULL;
        rt_bandstats rtn = NULL;

        Datum values[VALUES_LENGTH];
        bool nulls[VALUES_LENGTH];
        Datum result;

        /* tablename is null, return null */
        if (PG_ARGISNULL(0)) {
                elog(NOTICE, "Table name must be provided");
                PG_RETURN_NULL();
        }
        tablenametext = PG_GETARG_TEXT_P(0);
        tablename = text_to_cstring(tablenametext);
        if (!strlen(tablename)) {
                elog(NOTICE, "Table name must be provided");
                PG_RETURN_NULL();
        }

        /* column name is null, return null */
        if (PG_ARGISNULL(1)) {
                elog(NOTICE, "Column name must be provided");
                PG_RETURN_NULL();
        }
        colnametext = PG_GETARG_TEXT_P(1);
        colname = text_to_cstring(colnametext);
        if (!strlen(colname)) {
                elog(NOTICE, "Column name must be provided");
                PG_RETURN_NULL();
        }

        /* band index is 1-based */
        if (!PG_ARGISNULL(2))
                bandindex = PG_GETARG_INT32(2);

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

        /* sample % */
        if (!PG_ARGISNULL(4)) {
                sample = PG_GETARG_FLOAT8(4);
                if (sample < 0 || sample > 1) {
                        elog(NOTICE, "Invalid sample percentage (must be between 0 and 1). Returning NULL");
                        rt_raster_destroy(raster);
                        PG_RETURN_NULL();
                }
                else if (FLT_EQ(sample, 0.0))
                        sample = 1;
        }
        else
                sample = 1;

        /* iterate through rasters of coverage */
        /* connect to database */
        spi_result = SPI_connect();
        if (spi_result != SPI_OK_CONNECT) {
                pfree(sql);
                elog(ERROR, "RASTER_summaryStatsCoverage: Cannot connect to database using SPI");
                PG_RETURN_NULL();
        }

        /* create sql */
        len = sizeof(char) * (strlen("SELECT \"\" FROM \"\" WHERE \"\" IS NOT NULL") + (strlen(colname) * 2) + strlen(tablename) + 1);
        sql = (char *) palloc(len);
        if (NULL == sql) {
                if (SPI_tuptable) SPI_freetuptable(tuptable);
                SPI_finish();
                elog(ERROR, "RASTER_summaryStatsCoverage: Cannot allocate memory for sql");
                PG_RETURN_NULL();
        }

        /* get cursor */
        snprintf(sql, len, "SELECT \"%s\" FROM \"%s\" WHERE \"%s\" IS NOT NULL", colname, tablename, colname);
        portal = SPI_cursor_open_with_args(
                "coverage",
                sql,
                0, NULL,
                NULL, NULL,
                TRUE, 0
        );
        pfree(sql);

        /* process resultset */
        SPI_cursor_fetch(portal, TRUE, 1);
        while (SPI_processed == 1 && SPI_tuptable != NULL) {
                tupdesc = SPI_tuptable->tupdesc;
                tuptable = SPI_tuptable;
                tuple = tuptable->vals[0];

                datum = SPI_getbinval(tuple, tupdesc, 1, &isNull);
                if (SPI_result == SPI_ERROR_NOATTRIBUTE) {

                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                        SPI_cursor_close(portal);
                        SPI_finish();

                        if (NULL != rtn) pfree(rtn);
                        elog(ERROR, "RASTER_summaryStatsCoverage: Cannot get raster of coverage");
                        PG_RETURN_NULL();
                }
                else if (isNull) {
                        SPI_cursor_fetch(portal, TRUE, 1);
                        continue;
                }

                pgraster = (rt_pgraster *) PG_DETOAST_DATUM(datum);

                raster = rt_raster_deserialize(pgraster, FALSE);
                if (!raster) {

                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                        SPI_cursor_close(portal);
                        SPI_finish();

                        if (NULL != rtn) pfree(rtn);
                        elog(ERROR, "RASTER_summaryStatsCoverage: Cannot deserialize raster");
                        PG_RETURN_NULL();
                }

                /* inspect number of bands */
                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);

                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                        SPI_cursor_close(portal);
                        SPI_finish();

                        if (NULL != rtn) pfree(rtn);
                        PG_RETURN_NULL();
                }

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

                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                        SPI_cursor_close(portal);
                        SPI_finish();

                        if (NULL != rtn) pfree(rtn);
                        PG_RETURN_NULL();
                }

                /* we don't need the raw values, hence the zero parameter */
                stats = rt_band_get_summary_stats(band, (int) exclude_nodata_value, sample, 0, &cK, &cM, &cQ);

                rt_band_destroy(band);
                rt_raster_destroy(raster);

                if (NULL == stats) {
                        elog(NOTICE, "Cannot compute summary statistics for band at index %d. Returning NULL", bandindex);

                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                        SPI_cursor_close(portal);
                        SPI_finish();

                        if (NULL != rtn) pfree(rtn);
                        PG_RETURN_NULL();
                }

                /* initialize rtn */
                if (stats->count > 0) {
                        if (NULL == rtn) {
                                rtn = (rt_bandstats) SPI_palloc(sizeof(struct rt_bandstats_t));
                                if (NULL == rtn) {

                                        if (SPI_tuptable) SPI_freetuptable(tuptable);
                                        SPI_cursor_close(portal);
                                        SPI_finish();

                                        elog(ERROR, "RASTER_summaryStatsCoverage: Cannot allocate memory for summary stats of coverage");
                                        PG_RETURN_NULL();
                                }

                                rtn->sample = stats->sample;
                                rtn->count = stats->count;
                                rtn->min = stats->min;
                                rtn->max = stats->max;
                                rtn->sum = stats->sum;
                                rtn->mean = stats->mean;
                                rtn->stddev = -1;

                                rtn->values = NULL;
                                rtn->sorted = 0;
                        }
                        else {
                                rtn->count += stats->count;
                                rtn->sum += stats->sum;

                                if (stats->min < rtn->min)
                                        rtn->min = stats->min;
                                if (stats->max > rtn->max)
                                        rtn->max = stats->max;
                        }
                }

                pfree(stats);

                /* next record */
                SPI_cursor_fetch(portal, TRUE, 1);
        }

        if (SPI_tuptable) SPI_freetuptable(tuptable);
        SPI_cursor_close(portal);
        SPI_finish();

        if (NULL == rtn) {
                elog(ERROR, "RASTER_summaryStatsCoverage: Cannot compute coverage summary stats");
                PG_RETURN_NULL();
        }

        /* coverage mean and deviation */
        rtn->mean = rtn->sum / rtn->count;
        /* sample deviation */
        if (rtn->sample > 0 && rtn->sample < 1)
                rtn->stddev = sqrt(cQ / (rtn->count - 1));
        /* standard deviation */
        else
                rtn->stddev = sqrt(cQ / rtn->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);

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

        values[0] = Int64GetDatum(rtn->count);
        if (rtn->count > 0) {
                values[1] = Float8GetDatum(rtn->sum);
                values[2] = Float8GetDatum(rtn->mean);
                values[3] = Float8GetDatum(rtn->stddev);
                values[4] = Float8GetDatum(rtn->min);
                values[5] = Float8GetDatum(rtn->max);
        }
        else {
                nulls[1] = TRUE;
                nulls[2] = TRUE;
                nulls[3] = TRUE;
                nulls[4] = TRUE;
                nulls[5] = TRUE;
        }

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

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

        /* clean up */
        pfree(rtn);

        PG_RETURN_DATUM(result);
}

Here is the call graph for this function:

Here is the caller graph for this function: