rtpg_nmapalgebraexpr_callback()

static int rtpg_nmapalgebraexpr_callback ( rt_iterator_arg  arg, void *  userarg, double *  value, int *  nodata  )

static

Definition at line 1066 of file rtpg_mapalgebra.c.

  {
        rtpg_nmapalgebraexpr_callback_arg *callback = (rtpg_nmapalgebraexpr_callback_arg *) userarg;
        SPIPlanPtr plan = NULL;
        int i = 0;
        uint8_t id = 0;
 
        if (arg == NULL)
                return 0;
 
        *value = 0;
        *nodata = 0;
 
        /* 2 raster */
        if (arg->rasters > 1) {
                /* nodata1 = 1 AND nodata2 = 1, nodatanodataval */
                if (arg->nodata[0][0][0] && arg->nodata[1][0][0]) {
                        if (callback->nodatanodata.hasval)
                                *value = callback->nodatanodata.val;
                        else
                                *nodata = 1;
                }
                /* nodata1 = 1 AND nodata2 != 1, nodata1expr */
                else if (arg->nodata[0][0][0] && !arg->nodata[1][0][0]) {
                        id = 1;
                        if (callback->expr[id].hasval)
                                *value = callback->expr[id].val;
                        else if (callback->expr[id].spi_plan)
                                plan = callback->expr[id].spi_plan;
                        else
                                *nodata = 1;
                }
                /* nodata1 != 1 AND nodata2 = 1, nodata2expr */
                else if (!arg->nodata[0][0][0] && arg->nodata[1][0][0]) {
                        id = 2;
                        if (callback->expr[id].hasval)
                                *value = callback->expr[id].val;
                        else if (callback->expr[id].spi_plan)
                                plan = callback->expr[id].spi_plan;
                        else
                                *nodata = 1;
                }
                /* expression */
                else {
                        id = 0;
                        if (callback->expr[id].hasval)
                                *value = callback->expr[id].val;
                        else if (callback->expr[id].spi_plan)
                                plan = callback->expr[id].spi_plan;
                        else {
                                if (callback->nodatanodata.hasval)
                                        *value = callback->nodatanodata.val;
                                else
                                        *nodata = 1;
                        }
                }
        }
        /* 1 raster */
        else {
                /* nodata = 1, nodata1expr */
                if (arg->nodata[0][0][0]) {
                        id = 1;
                        if (callback->expr[id].hasval)
                                *value = callback->expr[id].val;
                        else if (callback->expr[id].spi_plan)
                                plan = callback->expr[id].spi_plan;
                        else
                                *nodata = 1;
                }
                /* expression */
                else {
                        id = 0;
                        if (callback->expr[id].hasval)
                                *value = callback->expr[id].val;
                        else if (callback->expr[id].spi_plan)
                                plan = callback->expr[id].spi_plan;
                        else {
                                /* see if nodata1expr is available */
                                id = 1;
                                if (callback->expr[id].hasval)
                                        *value = callback->expr[id].val;
                                else if (callback->expr[id].spi_plan)
                                        plan = callback->expr[id].spi_plan;
                                else
                                        *nodata = 1;
                        }
                }
        }
 
        /* run prepared plan */
        if (plan != NULL) {
                Datum values[12];
                char nulls[12];
                int err = 0;
 
                TupleDesc tupdesc;
                SPITupleTable *tuptable = NULL;
                HeapTuple tuple;
                Datum datum;
                bool isnull = FALSE;
 
                POSTGIS_RT_DEBUGF(4, "Running plan %d", id);
 
                /* init values and nulls */
                memset(values, (Datum) NULL, sizeof(Datum) * callback->kw.count);
                memset(nulls, FALSE, sizeof(char) * callback->kw.count);
 
                if (callback->expr[id].spi_argcount) {
                        int idx = 0;
 
                        for (i = 0; i < callback->kw.count; i++) {
                                idx = callback->expr[id].spi_argpos[i];
                                if (idx < 1) continue;
                                idx--; /* 1-based now 0-based */
 
                                if (arg->rasters == 1 && i > 7) {
                                        elog(ERROR, "rtpg_nmapalgebraexpr_callback: rast2 argument specified in single-raster invocation");
                                        return 0;
                                }
 
                                switch (i) {
                                        /* [rast.x] */
                                        case 0:
                                                values[idx] = Int32GetDatum(arg->src_pixel[0][0] + 1);
                                                break;
                                        /* [rast.y] */
                                        case 1:
                                                values[idx] = Int32GetDatum(arg->src_pixel[0][1] + 1);
                                                break;
                                        /* [rast.val] */
                                        case 2:
                                        /* [rast] */
                                        case 3:
                                                if (!arg->nodata[0][0][0])
                                                        values[idx] = Float8GetDatum(arg->values[0][0][0]);
                                                else
                                                        nulls[idx] = TRUE;
                                                break;
 
                                        /* [rast1.x] */
                                        case 4:
                                                values[idx] = Int32GetDatum(arg->src_pixel[0][0] + 1);
                                                break;
                                        /* [rast1.y] */
                                        case 5:
                                                values[idx] = Int32GetDatum(arg->src_pixel[0][1] + 1);
                                                break;
                                        /* [rast1.val] */
                                        case 6:
                                        /* [rast1] */
                                        case 7:
                                                if (!arg->nodata[0][0][0])
                                                        values[idx] = Float8GetDatum(arg->values[0][0][0]);
                                                else
                                                        nulls[idx] = TRUE;
                                                break;
 
                                        /* [rast2.x] */
                                        case 8:
                                                values[idx] = Int32GetDatum(arg->src_pixel[1][0] + 1);
                                                break;
                                        /* [rast2.y] */
                                        case 9:
                                                values[idx] = Int32GetDatum(arg->src_pixel[1][1] + 1);
                                                break;
                                        /* [rast2.val] */
                                        case 10:
                                        /* [rast2] */
                                        case 11:
                                                if (!arg->nodata[1][0][0])
                                                        values[idx] = Float8GetDatum(arg->values[1][0][0]);
                                                else
                                                        nulls[idx] = TRUE;
                                                break;
                                }
 
                        }
                }
 
                /* run prepared plan */
                err = SPI_execute_plan(plan, values, nulls, TRUE, 1);
                if (err != SPI_OK_SELECT || SPI_tuptable == NULL || SPI_processed != 1) {
                        elog(ERROR, "rtpg_nmapalgebraexpr_callback: Unexpected error when running prepared statement %d", id);
                        return 0;
                }
 
                /* get output of prepared plan */
                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);
                        elog(ERROR, "rtpg_nmapalgebraexpr_callback: Could not get result of prepared statement %d", id);
                        return 0;
                }
 
                if (!isnull) {
                        *value = DatumGetFloat8(datum);
                        POSTGIS_RT_DEBUG(4, "Getting value from Datum");
                }
                else {
                        /* 2 raster, check nodatanodataval */
                        if (arg->rasters > 1) {
                                if (callback->nodatanodata.hasval)
                                        *value = callback->nodatanodata.val;
                                else
                                        *nodata = 1;
                        }
                        /* 1 raster, check nodataval */
                        else {
                                if (callback->expr[1].hasval)
                                        *value = callback->expr[1].val;
                                else
                                        *nodata = 1;
                        }
                }
 
                if (SPI_tuptable) SPI_freetuptable(tuptable);
        }
 
        POSTGIS_RT_DEBUGF(4, "(value, nodata) = (%f, %d)", *value, *nodata);
        return 1;
}

References rtpg_nmapalgebraexpr_callback_arg::count, rtpg_nmapalgebraexpr_callback_arg::expr, FALSE, rtpg_nmapalgebraexpr_callback_arg::hasval, rtpg_nmapalgebraexpr_callback_arg::kw, rt_iterator_arg_t::nodata, rtpg_nmapalgebraexpr_callback_arg::nodatanodata, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, rt_iterator_arg_t::rasters, rtpg_nmapalgebraexpr_callback_arg::spi_argcount, rtpg_nmapalgebraexpr_callback_arg::spi_argpos, rtpg_nmapalgebraexpr_callback_arg::spi_plan, rt_iterator_arg_t::src_pixel, TRUE, rtpg_nmapalgebraexpr_callback_arg::val, genraster::value, and rt_iterator_arg_t::values.

Referenced by RASTER_nMapAlgebraExpr().

Here is the caller graph for this function: