RASTER_bandmetadata()

Datum RASTER_bandmetadata

(

PG_FUNCTION_ARGS

)

Definition at line 349 of file rtpg_band_properties.c.

References ovdump::band, FALSE, PG_FUNCTION_INFO_V1(), POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, rtrowdump::raster, RASTER_setBandNoDataValue(), rt_band_destroy(), rt_band_get_ext_path(), rt_band_get_hasnodata_flag(), rt_band_get_nodata(), rt_band_get_pixtype(), rt_pixtype_name(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_band(), rt_raster_get_num_bands(), TRUE, and VALUES_LENGTH.

{
        FuncCallContext *funcctx;
        TupleDesc tupdesc;
        int call_cntr;
        int max_calls;

        struct bandmetadata {
                uint32_t bandnum;
                char *pixeltype;
                bool hasnodata;
                double nodataval;
                bool isoutdb;
                char *bandpath;
        };
        struct bandmetadata *bmd = NULL;
        struct bandmetadata *bmd2 = NULL;

        HeapTuple tuple;
        Datum result;

        if (SRF_IS_FIRSTCALL()) {
                MemoryContext oldcontext;

                rt_pgraster *pgraster = NULL;
                rt_raster raster = NULL;
                rt_band band = NULL;

                ArrayType *array;
                Oid etype;
                Datum *e;
                bool *nulls;
                int16 typlen;
                bool typbyval;
                char typalign;
                int i = 0;
                int j = 0;
                int n = 0;

                uint32_t numBands;
                uint32_t idx = 1;
                uint32_t *bandNums = NULL;
                const char *tmp = NULL;

                POSTGIS_RT_DEBUG(3, "RASTER_bandmetadata: Starting");

                /* 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 null */
                if (PG_ARGISNULL(0)) {
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }
                pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));

                /* raster */
                raster = rt_raster_deserialize(pgraster, FALSE);
                if (!raster) {
                        PG_FREE_IF_COPY(pgraster, 0);
                        MemoryContextSwitchTo(oldcontext);
                        elog(ERROR, "RASTER_bandmetadata: Could not deserialize raster");
                        SRF_RETURN_DONE(funcctx);
                }

                /* numbands */
                numBands = rt_raster_get_num_bands(raster);
                if (numBands < 1) {
                        elog(NOTICE, "Raster provided has no bands");
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        MemoryContextSwitchTo(oldcontext);
                        SRF_RETURN_DONE(funcctx);
                }

                /* band index */
                array = PG_GETARG_ARRAYTYPE_P(1);
                etype = ARR_ELEMTYPE(array);
                get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);

                switch (etype) {
                        case INT2OID:
                        case INT4OID:
                                break;
                        default:
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                MemoryContextSwitchTo(oldcontext);
                                elog(ERROR, "RASTER_bandmetadata: Invalid data type for band number(s)");
                                SRF_RETURN_DONE(funcctx);
                                break;
                }

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

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

                        switch (etype) {
                                case INT2OID:
                                        idx = (uint32_t) DatumGetInt16(e[i]);
                                        break;
                                case INT4OID:
                                        idx = (uint32_t) DatumGetInt32(e[i]);
                                        break;
                        }

                        POSTGIS_RT_DEBUGF(3, "band idx (before): %d", idx);
                        if (idx > numBands || idx < 1) {
                                elog(NOTICE, "Invalid band index: %d. Indices must be 1-based. Returning NULL", idx);
                                pfree(bandNums);
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                MemoryContextSwitchTo(oldcontext);
                                SRF_RETURN_DONE(funcctx);
                        }

                        bandNums[j] = idx;
                        POSTGIS_RT_DEBUGF(3, "bandNums[%d] = %d", j, bandNums[j]);
                        j++;
                }

                if (j < 1) {
                        j = numBands;
                        bandNums = repalloc(bandNums, sizeof(uint32_t) * j);
                        for (i = 0; i < j; i++)
                                bandNums[i] = i + 1;
                }
                else if (j < n)
                        bandNums = repalloc(bandNums, sizeof(uint32_t) * j);

                bmd = (struct bandmetadata *) palloc(sizeof(struct bandmetadata) * j);

                for (i = 0; i < j; i++) {
                        band = rt_raster_get_band(raster, bandNums[i] - 1);
                        if (NULL == band) {
                                elog(NOTICE, "Could not get raster band at index %d", bandNums[i]);
                                rt_raster_destroy(raster);
                                PG_FREE_IF_COPY(pgraster, 0);
                                MemoryContextSwitchTo(oldcontext);
                                SRF_RETURN_DONE(funcctx);
                        }

                        /* bandnum */
                        bmd[i].bandnum = bandNums[i];

                        /* pixeltype */
                        tmp = rt_pixtype_name(rt_band_get_pixtype(band));
                        bmd[i].pixeltype = palloc(sizeof(char) * (strlen(tmp) + 1));
                        strncpy(bmd[i].pixeltype, tmp, strlen(tmp) + 1);

                        /* hasnodatavalue */
                        if (rt_band_get_hasnodata_flag(band))
                                bmd[i].hasnodata = TRUE;
                        else
                                bmd[i].hasnodata = FALSE;

                        /* nodatavalue */
                        if (bmd[i].hasnodata)
                                rt_band_get_nodata(band, &(bmd[i].nodataval));
                        else
                                bmd[i].nodataval = 0;

                        /* path */
                        tmp = rt_band_get_ext_path(band);
                        if (tmp) {
                                bmd[i].bandpath = palloc(sizeof(char) * (strlen(tmp) + 1));
                                strncpy(bmd[i].bandpath, tmp, strlen(tmp) + 1);
                        }
                        else
                                bmd[i].bandpath = NULL;

                        /* isoutdb */
                        bmd[i].isoutdb = bmd[i].bandpath ? TRUE : FALSE;

                        rt_band_destroy(band);
                }

                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);

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

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

                /* Build a tuple descriptor for our result type */
                if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) {
                        MemoryContextSwitchTo(oldcontext);
                        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;
        bmd2 = funcctx->user_fctx;

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

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

                values[0] = UInt32GetDatum(bmd2[call_cntr].bandnum);
                values[1] = CStringGetTextDatum(bmd2[call_cntr].pixeltype);

                if (bmd2[call_cntr].hasnodata)
                        values[2] = Float8GetDatum(bmd2[call_cntr].nodataval);
                else
                        nulls[2] = TRUE;

                values[3] = BoolGetDatum(bmd2[call_cntr].isoutdb);
                if (bmd2[call_cntr].bandpath && strlen(bmd2[call_cntr].bandpath))
                        values[4] = CStringGetTextDatum(bmd2[call_cntr].bandpath);
                else
                        nulls[4] = TRUE;

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

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

                /* clean up */
                pfree(bmd2[call_cntr].pixeltype);
                if (bmd2[call_cntr].bandpath) pfree(bmd2[call_cntr].bandpath);

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

Here is the call graph for this function: