Datum
#else // _MSC_VER
PGDLLEXPORT Datum
#endif
johnson(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
Matrix_cell_t *result_tuples = 0;
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 */
// CREATE OR REPLACE FUNCTION pgr_johnson(
// edges_sql TEXT,
// directed BOOLEAN,
PGR_DBG("Calling process");
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_BOOL(1),
&result_tuples,
&result_count);
/* */
/*********************************************************************/
funcctx->max_calls = (uint32_t)result_count;
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();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (Matrix_cell_t*) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
bool* nulls;
/*********************************************************************/
/* MODIFY AS NEEDED */
// OUT seq BIGINT,
// OUT from_vid BIGINT,
// OUT to_vid BIGINT,
// OUT cost float)
values = palloc(3 * sizeof(Datum));
nulls = palloc(3 * sizeof(bool));
// postgres starts counting from 1
values[0] = Int64GetDatum(result_tuples[call_cntr].from_vid);
nulls[0] = false;
values[1] = Int64GetDatum(result_tuples[call_cntr].to_vid);
nulls[1] = false;
values[2] = Float8GetDatum(result_tuples[call_cntr].cost);
nulls[2] = false;
/*********************************************************************/
tuple = heap_form_tuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
PGDLLEXPORT Datum
one_to_one_dijkstra(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
General_path_element_t *result_tuples = 0;
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 */
// CREATE OR REPLACE FUNCTION pgr_dijkstra(
// sql text, start_vids BIGINT,
// end_vid BIGINT,
// directed BOOLEAN default true,
PGR_DBG("Calling process");
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_INT64(1),
PG_GETARG_INT64(2),
PG_GETARG_BOOL(3),
PG_GETARG_BOOL(4),
&result_tuples,
&result_count);
/* */
/**********************************************************************/
funcctx->max_calls = (uint32_t)result_count;
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();
call_cntr = (uint32_t)funcctx->call_cntr;
max_calls = (uint32_t)funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (General_path_element_t*) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
bool* nulls;
/**********************************************************************/
/* MODIFY AS NEEDED */
// OUT seq INTEGER,
// OUT path_seq INTEGER,
// OUT node BIGINT,
// OUT edge BIGINT,
// OUT cost FLOAT,
// OUT agg_cost FLOAT
values = palloc(6 * sizeof(Datum));
nulls = palloc(6 * sizeof(bool));
size_t i;
for (i = 0; i < 6; ++i) {
nulls[i] = false;
}
// postgres starts counting from 1
values[0] = Int32GetDatum(call_cntr + 1);
values[1] = Int32GetDatum(result_tuples[call_cntr].seq);
values[2] = Int64GetDatum(result_tuples[call_cntr].node);
values[3] = Int64GetDatum(result_tuples[call_cntr].edge);
values[4] = Float8GetDatum(result_tuples[call_cntr].cost);
values[5] = Float8GetDatum(result_tuples[call_cntr].agg_cost);
/**********************************************************************/
tuple = heap_form_tuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
Datum
#else // _MSC_VER
PGDLLEXPORT Datum
#endif
one_to_one_withPoints(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/*******************************************************************************/
/* MODIFY AS NEEDED */
/* */
General_path_element_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 */
// CREATE OR REPLACE FUNCTION pgr_withPoint(
// edges_sql TEXT,
// points_sql TEXT,
// start_pid BIGINT,
// end_pid BIGINT,
// directed BOOLEAN -- DEFAULT true,
// driving_side CHAR -- DEFAULT 'b',
// details BOOLEAN -- DEFAULT true,
// only_cost BOOLEAN DEFAULT false,
PGR_DBG("Calling process");
PGR_DBG("initial driving side:%s", pgr_text2char(PG_GETARG_TEXT_P(5)));
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
pgr_text2char(PG_GETARG_TEXT_P(1)),
PG_GETARG_INT64(2),
PG_GETARG_INT64(3),
PG_GETARG_BOOL(4),
pgr_text2char(PG_GETARG_TEXT_P(5)),
PG_GETARG_BOOL(6),
PG_GETARG_BOOL(7),
&result_tuples,
&result_count);
/* */
/*******************************************************************************/
funcctx->max_calls = (uint32_t)result_count;
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();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (General_path_element_t*) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
char* nulls;
/*******************************************************************************/
/* MODIFY AS NEEDED */
// OUT seq BIGINT,
// OUT path_seq,
// OUT node BIGINT,
// OUT edge BIGINT,
// OUT cost FLOAT,
// OUT agg_cost FLOAT)
values = palloc(6 * sizeof(Datum));
nulls = palloc(6 * sizeof(char));
size_t i;
for(i = 0; i < 6; ++i) {
nulls[i] = ' ';
}
// postgres starts counting from 1
values[0] = Int32GetDatum(call_cntr + 1);
values[1] = Int32GetDatum(result_tuples[call_cntr].seq);
values[2] = Int64GetDatum(result_tuples[call_cntr].node);
values[3] = Int64GetDatum(result_tuples[call_cntr].edge);
values[4] = Float8GetDatum(result_tuples[call_cntr].cost);
values[5] = Float8GetDatum(result_tuples[call_cntr].agg_cost);
/*******************************************************************************/
tuple = heap_formtuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
Datum
#else // _MSC_VER
PGDLLEXPORT Datum
#endif
driving_many_to_dist(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
int call_cntr;
int max_calls;
TupleDesc tuple_desc;
pgr_path_element3_t *ret_path = 0;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL()) {
MemoryContext oldcontext;
int path_count = 0;
/* 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);
int64_t* sourcesArr;
int num;
sourcesArr = (int64_t*) pgr_get_bigIntArray(&num, PG_GETARG_ARRAYTYPE_P(1));
PGR_DBG("sourcesArr size %d ", num);
PGR_DBG("Calling driving_many_to_dist_driver");
driving_many_to_dist_driver(
pgr_text2char(PG_GETARG_TEXT_P(0)), // sql
sourcesArr, num, // array of sources
PG_GETARG_FLOAT8(2), // distance
PG_GETARG_BOOL(3), // directed
PG_GETARG_BOOL(4), // equicost
PG_GETARG_BOOL(5), // has_rcost
&ret_path, &path_count);
free(sourcesArr);
/* total number of tuples to be returned */
funcctx->max_calls = path_count;
funcctx->user_fctx = ret_path;
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);
}
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
ret_path = (pgr_path_element3_t*) funcctx->user_fctx;
/* do when there is more left to send */
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
char* nulls;
values = palloc(6 * sizeof(Datum));
nulls = palloc(6 * sizeof(char));
// id, start_v, node, edge, cost, tot_cost
values[0] = Int32GetDatum(call_cntr + 1);
nulls[0] = ' ';
values[1] = Int64GetDatum(ret_path[call_cntr].from);
nulls[1] = ' ';
values[2] = Int64GetDatum(ret_path[call_cntr].vertex);
nulls[2] = ' ';
values[3] = Int64GetDatum(ret_path[call_cntr].edge);
nulls[3] = ' ';
values[4] = Float8GetDatum(ret_path[call_cntr].cost);
nulls[4] = ' ';
values[5] = Float8GetDatum(ret_path[call_cntr].tot_cost);
nulls[5] = ' ';
tuple = heap_formtuple(tuple_desc, values, nulls);
/* make the tuple into a datum */
result = HeapTupleGetDatum(tuple);
/* clean up (this is not really necessary) */
pfree(values);
pfree(nulls);
SRF_RETURN_NEXT(funcctx, result);
} else {
/* do when there is no more left */
if (ret_path) free(ret_path);
SRF_RETURN_DONE(funcctx);
}
}
PGDLLEXPORT Datum
maximum_cardinality_matching(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
pgr_basic_edge_t *result_tuples = 0;
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 */
PGR_DBG("Calling process");
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_BOOL(1),
&result_tuples,
&result_count);
/* */
/**********************************************************************/
funcctx->max_calls = (uint32_t) result_count;
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();
call_cntr = (uint32_t)funcctx->call_cntr;
max_calls = (uint32_t)funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (pgr_basic_edge_t *) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
bool *nulls;
/**********************************************************************/
/* MODIFY AS NEEDED */
values = palloc(4 * sizeof(Datum));
nulls = palloc(4 * sizeof(bool));
size_t i;
for (i = 0; i < 4; ++i) {
nulls[i] = false;
}
// postgres starts counting from 1
values[0] = Int32GetDatum(call_cntr + 1);
values[1] = Int64GetDatum(result_tuples[call_cntr].edge_id);
values[2] = Int64GetDatum(result_tuples[call_cntr].source);
values[3] = Int64GetDatum(result_tuples[call_cntr].target);
/**********************************************************************/
tuple = heap_form_tuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
Datum
#else // _MSC_VER
PGDLLEXPORT Datum
#endif
MY_FUNCTION_NAME(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
MY_RETURN_VALUE_TYPE *result_tuples = 0;
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 */
/*
MY_QUERY_LINE1
**********************************************************************/
PGR_DBG("Initializing arrays");
int64_t* end_vidsArr;
size_t size_end_vidsArr;
end_vidsArr = (int64_t*) pgr_get_bigIntArray(&size_end_vidsArr, PG_GETARG_ARRAYTYPE_P(2));
PGR_DBG("targetsArr size %ld ", size_end_vidsArr);
PGR_DBG("Calling process");
// Code standard:
// Use same order as in the query
// Pass the array and it's size on the same line
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_INT64(1),
end_vidsArr, size_end_vidsArr,
PG_GETARG_BOOL(3),
&result_tuples,
&result_count);
// while developing leave the message as a reminder
PGR_DBG("Cleaning arrays using free(<array-name>)");
free(end_vidsArr);
/* */
/*******************************************************************************/
funcctx->max_calls = (uint32_t) result_count;
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();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (MY_RETURN_VALUE_TYPE*) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
bool* nulls;
/*******************************************************************************/
/* MODIFY!!!!! */
/* This has to match you ouput otherwise the server crashes */
/*
MY_QUERY_LINE2
********************************************************************************/
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(call_cntr + 1);
values[1] = Int32GetDatum(result_tuples[call_cntr].seq);
values[2] = Int64GetDatum(result_tuples[call_cntr].start_id);
values[3] = Int64GetDatum(result_tuples[call_cntr].end_id);
values[4] = Int64GetDatum(result_tuples[call_cntr].node);
values[5] = Int64GetDatum(result_tuples[call_cntr].edge);
values[6] = Float8GetDatum(result_tuples[call_cntr].cost);
values[7] = Float8GetDatum(result_tuples[call_cntr].agg_cost);
/*******************************************************************************/
tuple = heap_form_tuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
Datum
#else // _MSC_VER
PGDLLEXPORT Datum
#endif
one_to_many_dijkstra(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
General_path_element_t *result_tuples = 0;
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 */
// CREATE OR REPLACE FUNCTION pgr_dijkstra(sql text,
// start_vid bigint,
// end_vids anyarray,
// directed boolean default true,
// only_cost boolean default false
PGR_DBG("Initializing arrays");
int64_t* end_vidsArr;
size_t size_end_vidsArr;
end_vidsArr = (int64_t*)
pgr_get_bigIntArray(&size_end_vidsArr, PG_GETARG_ARRAYTYPE_P(2));
PGR_DBG("targetsArr size %ld ", size_end_vidsArr);
PGR_DBG("Calling process");
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_INT64(1),
end_vidsArr, size_end_vidsArr,
PG_GETARG_BOOL(3),
PG_GETARG_BOOL(4),
&result_tuples,
&result_count);
PGR_DBG("Cleaning arrays");
free(end_vidsArr);
/* */
/**********************************************************************/
funcctx->max_calls = (uint32_t)result_count;
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();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (General_path_element_t*) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
char* nulls;
/*********************************************************************/
/* MODIFY AS NEEDED */
// OUT seq integer,
// OUT path_seq INTEGER,
// OUT end_vid BIGINT,
// OUT node bigint,
// OUT edge bigint,
// OUT cost float,
// OUT agg_cost float)
values = palloc(7 * sizeof(Datum));
nulls = palloc(7 * sizeof(char));
size_t i;
for (i = 0; i < 7; ++i) {
nulls[i] = ' ';
}
// postgres starts counting from 1
values[0] = Int32GetDatum(call_cntr + 1);
values[1] = Int32GetDatum(result_tuples[call_cntr].seq);
values[2] = Int64GetDatum(result_tuples[call_cntr].end_id);
values[3] = Int64GetDatum(result_tuples[call_cntr].node);
values[4] = Int64GetDatum(result_tuples[call_cntr].edge);
values[5] = Float8GetDatum(result_tuples[call_cntr].cost);
values[6] = Float8GetDatum(result_tuples[call_cntr].agg_cost);
/*********************************************************************/
tuple = heap_formtuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
PGDLLEXPORT Datum
edge_disjoint_paths_many_to_one(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
/**************************************************************************/
/* MODIFY AS NEEDED */
/* */
General_path_element_t *result_tuples = 0;
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 */
int64_t *source_vertices;
size_t size_source_verticesArr;
source_vertices = (int64_t *)
pgr_get_bigIntArray(&size_source_verticesArr,
PG_GETARG_ARRAYTYPE_P(1));
PGR_DBG("source_verticesArr size %ld ", size_source_verticesArr);
PGR_DBG("Calling process");
process(
pgr_text2char(PG_GETARG_TEXT_P(0)),
source_vertices, size_source_verticesArr,
PG_GETARG_INT64(2),
PG_GETARG_BOOL(3),
&result_tuples,
&result_count);
free(source_vertices);
/* */
/**********************************************************************/
funcctx->max_calls = (uint32_t) result_count;
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();
call_cntr = (uint32_t)funcctx->call_cntr;
max_calls = (uint32_t)funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
result_tuples = (General_path_element_t *) funcctx->user_fctx;
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
bool *nulls;
/**********************************************************************/
/* MODIFY AS NEEDED */
values = palloc(5 * sizeof(Datum));
nulls = palloc(5 * sizeof(bool));
size_t i;
for (i = 0; i < 5; ++i) {
nulls[i] = false;
}
// postgres starts counting from 1
values[0] = Int32GetDatum(call_cntr + 1);
values[1] = Int32GetDatum(result_tuples[call_cntr].seq);
values[2] = Int64GetDatum(result_tuples[call_cntr].start_id);
values[3] = Int64GetDatum(result_tuples[call_cntr].node);
values[4] = Int64GetDatum(result_tuples[call_cntr].edge);
/**********************************************************************/
tuple = heap_form_tuple(tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
// cleanup
if (result_tuples) free(result_tuples);
SRF_RETURN_DONE(funcctx);
}
}
Datum
shortest_path(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
int call_cntr;
int max_calls;
TupleDesc tuple_desc;
pgr_path_element3_t *ret_path = 0;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL()) {
MemoryContext oldcontext;
int path_count = 0;
/* 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);
compute_shortest_path(pgr_text2char(PG_GETARG_TEXT_P(0)),
PG_GETARG_INT64(1),
PG_GETARG_INT64(2),
PG_GETARG_BOOL(3),
PG_GETARG_BOOL(4), &ret_path, &path_count);
/* total number of tuples to be returned */
funcctx->max_calls = path_count;
funcctx->user_fctx = ret_path;
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);
}
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
ret_path = (pgr_path_element3_t*) funcctx->user_fctx;
/* do when there is more left to send */
if (call_cntr < max_calls) {
HeapTuple tuple;
Datum result;
Datum *values;
char* nulls;
values = palloc(6 * sizeof(Datum));
nulls = palloc(6 * sizeof(char));
values[0] = Int32GetDatum(ret_path[call_cntr].seq);
nulls[0] = ' ';
values[1] = Int32GetDatum(ret_path[call_cntr].seq);
nulls[1] = ' ';
values[2] = Int64GetDatum(ret_path[call_cntr].vertex);
nulls[2] = ' ';
values[3] = Int64GetDatum(ret_path[call_cntr].edge);
nulls[3] = ' ';
values[4] = Float8GetDatum(ret_path[call_cntr].cost);
nulls[4] = ' ';
values[5] = Float8GetDatum(ret_path[call_cntr].tot_cost);
nulls[5] = ' ';
tuple = heap_formtuple(tuple_desc, values, nulls);
/* make the tuple into a datum */
result = HeapTupleGetDatum(tuple);
/* clean up (this is not really necessary) */
pfree(values);
pfree(nulls);
SRF_RETURN_NEXT(funcctx, result);
} else {
/* do when there is no more left */
if (ret_path) free(ret_path);
SRF_RETURN_DONE(funcctx);
}
}
Datum
turn_restrict_shortest_path_edge(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
uint32_t call_cntr;
uint32_t max_calls;
TupleDesc tuple_desc;
path_element_t *path;
char * sql;
// stuff done only on the first call of the function
if (SRF_IS_FIRSTCALL()) {
MemoryContext oldcontext;
size_t path_count = 0;
#ifdef DEBUG
int ret = -1;
#endif
int i;
double s_pos;
double e_pos;
// 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);
// verify that the first 5 args are not NULL
for (i=0; i<7; i++) {
if(i==2 || i==4) continue;
if(PG_ARGISNULL(i)) {
elog(ERROR, "turn_restrict_shortest_path(): Argument %i may not be NULL", i+1);
}
}
if (PG_ARGISNULL(2))
s_pos = 0.5;
else {
s_pos = PG_GETARG_FLOAT8(2);
if (s_pos < 0.0) s_pos = 0.5;
if (s_pos > 1.0) s_pos = 0.5;
}
if (PG_ARGISNULL(4))
e_pos = 0.5;
else {
e_pos = PG_GETARG_FLOAT8(4);
if (e_pos < 0.0) e_pos = 0.5;
if (e_pos > 1.0) e_pos = 0.5;
}
if (PG_ARGISNULL(7))
sql = NULL;
else {
sql = pgr_text2char(PG_GETARG_TEXT_P(7));
if (strlen(sql) == 0)
sql = NULL;
}
PGR_DBG("Calling compute_trsp");
#ifdef DEBUG
ret =
#endif
compute_trsp(pgr_text2char(PG_GETARG_TEXT_P(0)),
0, //sdo edge
PG_GETARG_INT32(1),
s_pos,
PG_GETARG_INT32(3),
e_pos,
PG_GETARG_BOOL(5),
PG_GETARG_BOOL(6),
sql,
&path, &path_count);
#ifdef DEBUG
double total_cost = 0;
PGR_DBG("Ret is %i", ret);
if (ret >= 0)
{
int i;
for (i = 0; i < path_count; i++)
{
// PGR_DBG("Step %i vertex_id %i ", i, path[i].vertex_id);
// PGR_DBG(" edge_id %i ", path[i].edge_id);
// PGR_DBG(" cost %f ", path[i].cost);
total_cost+=path[i].cost;
}
}
PGR_DBG("Total cost is: %f",total_cost);
#endif
// total number of tuples to be returned
funcctx->max_calls = (uint32_t)path_count;
funcctx->user_fctx = path;
funcctx->tuple_desc =
BlessTupleDesc(RelationNameGetTupleDesc("pgr_costResult"));
MemoryContextSwitchTo(oldcontext);
}
// stuff done on every call of the function
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
tuple_desc = funcctx->tuple_desc;
path = (path_element_t*) funcctx->user_fctx;
if (call_cntr < max_calls) // do when there is more left to send
{
HeapTuple tuple;
Datum result;
Datum *values;
bool* nulls;
values = palloc(4 * sizeof(Datum));
nulls = palloc(4 * sizeof(bool));
values[0] = Int32GetDatum(call_cntr);
nulls[0] = false;
values[1] = Int32GetDatum(path[call_cntr].vertex_id);
nulls[1] = false;
values[2] = Int32GetDatum(path[call_cntr].edge_id);
nulls[2] = false;
values[3] = Float8GetDatum(path[call_cntr].cost);
nulls[3] = false;
tuple = heap_form_tuple(tuple_desc, values, nulls);
// make the tuple into a datum
result = HeapTupleGetDatum(tuple);
// clean up (this is not really necessary)
pfree(values);
pfree(nulls);
SRF_RETURN_NEXT(funcctx, result);
}
else // do when there is no more left
{
PGR_DBG("Going to free path");
if (path) free(path);
SRF_RETURN_DONE(funcctx);
}
}
