query.c

Go to the documentation of this file.

#include <stdio.h>
#include "postgres.h"
#include "catalog/pg_type.h"
#include "executor/spi.h"
#include "access/xact.h"
#include "veil2.h"


void
veil2_spi_connect(bool *p_pushed, const char *msg)
{
    int result = SPI_connect();
    if (result == SPI_ERROR_CONNECT) {
        SPI_push();
        *p_pushed = true;
        result = SPI_connect();
    }
    else {
        *p_pushed = false;
    }
    if (result != SPI_OK_CONNECT) {
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("%s", msg),
                 errdetail("SPI_connect() failed, returning %d.", result)));
    }
}

void
veil2_spi_finish(bool pushed, const char *msg)
{
    int spi_result = SPI_finish();
    if (pushed) {
        SPI_pop();
    }
    if (spi_result != SPI_OK_FINISH) {
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("%s", msg),
                 errdetail("SPI_finish() failed, returning %d.", spi_result)));
    }
}

static void
prepare_query(const char *qry,
              int nargs,
              Oid *argtypes,
              Datum *args,
              const char *nulls,
              bool read_only,
              void **saved_plan)
{
    void   *plan;
    int     exec_result;
    
    if (saved_plan && *saved_plan) {
        /* A previously prepared plan is available, so use it */
        plan = *saved_plan;
    }
    else {
        if (!(plan = SPI_prepare(qry, nargs, argtypes))) {
            ereport(ERROR,
                    (errcode(ERRCODE_INTERNAL_ERROR),
                     errmsg("prepare_query fails"),
                     errdetail("SPI_prepare('%s') returns NULL "
                               "(SPI_result = %d)", 
                               qry, SPI_result)));
        }

        if (saved_plan) {
            /* We have somewhere to put the saved plan, so save  it. */
            *saved_plan = SPI_saveplan(plan);
        }
    }
    
    exec_result = SPI_execute_plan(plan, args, nulls, read_only, 0);
    if (exec_result < 0) {
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("prepare_query fails"),
                 errdetail("SPI_execute_plan('%s') returns error %d",
                           qry, exec_result)));
    }
}

int
veil2_query_wn(const char *qry,
               int nargs,
               Oid *argtypes,
               Datum *args,
               const char *nulls,
               bool  read_only,
               void **saved_plan,
               Fetch_fn process_row,
               void *fn_param)
{
    int  row;
    int  fetched;
    int  processed = 0;
    bool cntinue;
    SPITupleTable *tuptab;

    prepare_query(qry, nargs, argtypes, args, nulls, read_only, saved_plan);
    fetched = SPI_processed;
    tuptab = SPI_tuptable;
    if (process_row) {
        for(row = 0; row < fetched; row++) {
            processed++;
            /* Process a row using the processor function */
            cntinue = process_row(tuptab->vals[row], 
                                  tuptab->tupdesc,
                                  fn_param);
            if (!cntinue) {
                break;
            }
        }
    }
    return processed;
}

int
veil2_query(const char *qry,
            int nargs,
            Oid *argtypes,
            Datum *args,
            bool  read_only,
            void **saved_plan,
            Fetch_fn process_row,
            void *fn_param)
{
    return veil2_query_wn(qry, nargs, argtypes, args, NULL,
                          read_only, saved_plan, process_row, fn_param);
}

static bool
fetch_one_bool(HeapTuple tuple, TupleDesc tupdesc, void *p_result)
{
    bool is_null = false;
    bool col = DatumGetBool(SPI_getbinval(tuple, tupdesc, 1, &is_null));
    *((bool *) p_result) = col;
    
    return false;
}

bool
veil2_bool_from_query(const char *qry,
                      int nargs,
                      Oid *argtypes,
                      Datum *args,
                      void **saved_plan,
                      bool *result)
{
    int     rows;
    rows = veil2_query(qry, nargs, argtypes, args, false, saved_plan, 
                       fetch_one_bool, (void *) result);
    return (rows > 0);
}