minCostMaxFlow.c File Reference

Connecting code with postgres. More...

#include <stdbool.h>
#include "c_common/postgres_connection.h"
#include "utils/array.h"
#include "c_common/debug_macro.h"
#include "c_common/e_report.h"
#include "c_common/time_msg.h"
#include "c_common/edges_input.h"
#include "c_common/arrays_input.h"
#include "c_common/combinations_input.h"
#include "drivers/max_flow/minCostMaxFlow_driver.h"

Include dependency graph for minCostMaxFlow.c:

Go to the source code of this file.

Functions
PGDLLEXPORT Datum	_pgr_maxflowmincost (PG_FUNCTION_ARGS)
	postgres_connection.h More...
	PG_FUNCTION_INFO_V1 (_pgr_maxflowmincost)
static void	process (char *edges_sql, char *combinations_sql, ArrayType *starts, ArrayType *ends, bool only_cost, pgr_flow_t **result_tuples, size_t *result_count)

Detailed Description

Connecting code with postgres.

This file is fully documented for understanding how the postgres connectinon works

TODO Remove unnecessary comments before submiting the function. some comments are in form of PGR_DBG message

Definition in file minCostMaxFlow.c.

Function Documentation

_pgr_maxflowmincost()

PGDLLEXPORT Datum _pgr_maxflowmincost

(

PG_FUNCTION_ARGS

)

postgres_connection.h

• should always be first in the C code

Definition at line 178 of file minCostMaxFlow.c.

                                                        {
    FuncCallContext     *funcctx;
    TupleDesc           tuple_desc;
 
    /**************************************************************************/
    /*                          MODIFY AS NEEDED                              */
    /*                                                                        */
    pgr_flow_t *result_tuples = NULL;
    size_t result_count = 0;
    /*                                                                        */
    /**************************************************************************/
 
    if (SRF_IS_FIRSTCALL()) {
        MemoryContext   oldcontext;
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
 
        /**********************************************************************/
        /*                          MODIFY AS NEEDED                          */
        /*
           TEXT,
    BIGINT,
    BIGINT,
         **********************************************************************/
 
 
        PGR_DBG("Calling process");
 
        if (PG_NARGS() == 4) {
            /*
             * many to many
             */
            process(
                text_to_cstring(PG_GETARG_TEXT_P(0)),
                NULL,
                PG_GETARG_ARRAYTYPE_P(1),
                PG_GETARG_ARRAYTYPE_P(2),
                PG_GETARG_BOOL(3),
                &result_tuples,
                &result_count);
 
        } else if (PG_NARGS() == 3) {
            /*
             * combinations
             */
            process(
                text_to_cstring(PG_GETARG_TEXT_P(0)),
                text_to_cstring(PG_GETARG_TEXT_P(1)),
                NULL,
                NULL,
                PG_GETARG_BOOL(2),
                &result_tuples,
                &result_count);
        }
 
        /*                                                                    */
        /**********************************************************************/
 
#if PGSQL_VERSION > 94
        funcctx->max_calls = (uint32_t)result_count;
#else
        funcctx->max_calls = (uint32_t)result_count;
#endif
        funcctx->user_fctx = result_tuples;
        if (get_call_result_type(fcinfo, NULL, &tuple_desc)
                != TYPEFUNC_COMPOSITE) {
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("function returning record called in context "
                         "that cannot accept type record")));
        }
 
        funcctx->tuple_desc = tuple_desc;
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    tuple_desc = funcctx->tuple_desc;
    result_tuples = (pgr_flow_t*) funcctx->user_fctx;
 
    if (funcctx->call_cntr < funcctx->max_calls) {
        HeapTuple    tuple;
        Datum        result;
        Datum        *values;
        bool*        nulls;
 
        /**********************************************************************/
        /*                          MODIFY AS NEEDED                          */
        /*
         ***********************************************************************/
 
        values = palloc(8 * sizeof(Datum));
        nulls = palloc(8 * sizeof(bool));
 
 
        size_t i;
        for (i = 0; i < 8; ++i) {
            nulls[i] = false;
        }
 
        // postgres starts counting from 1
        values[0] = Int32GetDatum(funcctx->call_cntr + 1);
        values[1] = Int64GetDatum(result_tuples[funcctx->call_cntr].edge);
        values[2] = Int64GetDatum(result_tuples[funcctx->call_cntr].source);
        values[3] = Int64GetDatum(result_tuples[funcctx->call_cntr].target);
        values[4] = Int64GetDatum(result_tuples[funcctx->call_cntr].flow);
        values[5] = Int64GetDatum(
                result_tuples[funcctx->call_cntr].residual_capacity);
        values[6] = Float8GetDatum(result_tuples[funcctx->call_cntr].cost);
        values[7] = Float8GetDatum(result_tuples[funcctx->call_cntr].agg_cost);
        /**********************************************************************/
 
        tuple = heap_form_tuple(tuple_desc, values, nulls);
        result = HeapTupleGetDatum(tuple);
        SRF_RETURN_NEXT(funcctx, result);
    } else {
        /**********************************************************************/
        /*                          MODIFY AS NEEDED                          */
 
        PGR_DBG("Clean up code");
 
        /**********************************************************************/
 
        SRF_RETURN_DONE(funcctx);
    }
}

References pgr_flow_t::agg_cost, pgr_flow_t::cost, pgr_flow_t::edge, pgr_flow_t::flow, if(), PGR_DBG, process(), pgr_flow_t::residual_capacity, pgr_flow_t::source, and pgr_flow_t::target.

PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1

(

_pgr_maxflowmincost

)

process()

static void process ( char *  edges_sql, char *  combinations_sql, ArrayType *  starts, ArrayType *  ends, bool  only_cost, pgr_flow_t **  result_tuples, size_t *  result_count  )

static

Definition at line 73 of file minCostMaxFlow.c.

                              {
    /*
     *  https://www.postgresql.org/docs/current/static/spi-spi-connect.html
     */
    pgr_SPI_connect();
 
    int64_t *sourceVertices = NULL;
    size_t sizeSourceVerticesArr = 0;
 
    int64_t *sinkVertices = NULL;
    size_t sizeSinkVerticesArr = 0;
 
    PGR_DBG("Load data");
    pgr_costFlow_t *edges = NULL;
    size_t total_edges = 0;
 
    pgr_combination_t *combinations = NULL;
    size_t total_combinations = 0;
 
    if (starts && ends) {
        sourceVertices = (int64_t*)
            pgr_get_bigIntArray(&sizeSourceVerticesArr, starts);
        sinkVertices = (int64_t*)
            pgr_get_bigIntArray(&sizeSinkVerticesArr, ends);
    } else if (combinations_sql) {
        pgr_get_combinations(combinations_sql, &combinations, &total_combinations);
        if (total_combinations == 0) {
            if (combinations)
                pfree(combinations);
            pgr_SPI_finish();
            return;
        }
    }
 
    pgr_get_costFlow_edges(edges_sql, &edges, &total_edges);
    PGR_DBG("Total %ld edges in query:", total_edges);
 
    if (total_edges == 0) {
        if (sourceVertices)
            pfree(sourceVertices);
        if (sinkVertices)
            pfree(sinkVertices);
        PGR_DBG("No edges found");
        pgr_SPI_finish();
        return;
    }
 
    PGR_DBG("Starting processing");
    clock_t start_t = clock();
    char *log_msg = NULL;
    char *notice_msg = NULL;
    char *err_msg = NULL;
 
    do_pgr_minCostMaxFlow(
            edges, total_edges,
            combinations, total_combinations,
            sourceVertices, sizeSourceVerticesArr,
            sinkVertices, sizeSinkVerticesArr,
            only_cost,
 
            result_tuples, result_count,
 
            &log_msg,
            &notice_msg,
            &err_msg);
 
    if (only_cost) {
        time_msg(" processing pgr_minCostMaxFlow_Cost", start_t, clock());
    } else {
        time_msg(" processing pgr_minCostMaxFlow", start_t, clock());
    }
 
    PGR_DBG("Returning %ld tuples", *result_count);
 
    if (edges)
        pfree(edges);
    if (sourceVertices)
        pfree(sourceVertices);
    if (sinkVertices)
        pfree(sinkVertices);
 
    if (err_msg && (*result_tuples)) {
        pfree(*result_tuples);
        (*result_tuples) = NULL;
        (*result_count) = 0;
    }
 
    pgr_global_report(log_msg, notice_msg, err_msg);
 
    if (log_msg) pfree(log_msg);
    if (notice_msg) pfree(notice_msg);
    if (err_msg) pfree(err_msg);
 
    pgr_SPI_finish();
}

References do_pgr_minCostMaxFlow(), PGR_DBG, pgr_get_bigIntArray(), pgr_get_combinations(), pgr_get_costFlow_edges(), pgr_global_report(), pgr_SPI_connect(), pgr_SPI_finish(), and time_msg().

Referenced by _pgr_maxflowmincost().