Re: function returning a row

On Wednesday 15 December 2004 18:05, Michael Fuhr wrote:
> On Wed, Dec 15, 2004 at 07:16:20AM -0800, Joe Conway wrote:
> See also "Returning Sets from C-Language Functions" in the "C-Language
> Functions" section of the "Extending SQL" chapter in the documentation.

Hi again.

I know it is kind of an old thread, but i have some problems with getting this
function to work. When i run it in the database, the database crashes. The
last thing it prints out before it stops is "return next". I have added my
code here, sorry that there is that much, but i didn't find anything that i
could leave out. I don't know if i need to have the tables in the structure,
since it is allocated with multi_call_memory, but i have tried with and
without it in the structure, and it didn't make any difference. Hope someone
can help.

thanks
- Kjetil

typedef struct {
bool finished;
int x_value;
int y_value;
int min_value;
int max_x;
int max_y;
int **dynamic;
int **backtracking;
bool **before;
}set_data;

Datum smith_waterman_set(PG_FUNCTION_ARGS) {
FuncCallContext *funcctx;
MemoryContext oldcontext;
int call_cntr;

set_data *set;
int x_value, y_value, max_x, max_y;
int min_value;
int **dynamic;
int **backtracking;
bool **before;
char *in;
char *sml;
char g[2]="-";

if(SRF_IS_FIRSTCALL()) {
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

set = (set_data *) palloc(sizeof(*set));

text *intext = PG_GETARG_TEXT_P(0);
text *smltext = PG_GETARG_TEXT_P(1);
in = (char*)palloc(VARSIZE(intext)-VARHDRSZ+1);
sml = (char*)palloc(VARSIZE(smltext)-VARHDRSZ+1);
snprintf (in, VARSIZE(intext) - VARHDRSZ + 1, VARDATA(intext));
snprintf (sml, VARSIZE(smltext) - VARHDRSZ + 1, VARDATA(smltext));

dynamic = (int **) palloc((1+strlen(in))* sizeof(int));
backtracking = (int **) palloc((1+strlen(in)) *sizeof(int));
before = (bool **) palloc((1+strlen(in))*sizeof(bool));

if(dynamic == NULL) {
printf("\n failed to allocate memory for dynamic");
ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR),
errmsg("failed to allocate memory for dynamic")));
}

int i, j, diag, up, left, max, s, maxi, maxj;
int maxvalue = -1;
for(i=0; i<strlen(in)+1; i++) {
dynamic[i] = palloc((1+strlen(sml))* sizeof(int));
backtracking[i] = palloc((1+strlen(sml))*sizeof(int));
before[i] = palloc((1+strlen(sml))*sizeof(bool));
if(dynamic[i] == NULL) {
printf("\nfailed to allocate for dynamic[%d]", i);
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("failed to allocate memory for dynamic[%d]", i)));
}
if(backtracking[i] == NULL) {
printf("\nfailed to allocate for backtracking[%d]", i);
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("failed to allocate memory for backtracking[%d]", i)));
}
}

//sets up the dynamic programing table,
//all values are zero since it is local similarity
for(i=0; i<strlen(in)+1; i++) {
for(j=0; j<strlen(sml)+1; j++) {
dynamic[i][j] = 0;
backtracking[i][j] = 0;
}
}

for(i=0; i<strlen(in); i++) {
for(j=0; j<strlen(sml); j++) {
s = score(in+i, sml+j);

diag = dynamic[i][j] + s;
up = dynamic[i][j+1] + s - gap;
left = dynamic[i+1][j] + s - gap;

max = MAX3(diag, up, left);

if(max <= 0) {
dynamic[i+1][j+1] = 0;
backtracking[i+1][j+1] = 0;
}
else if(max == diag) {
dynamic[i+1][j+1] = diag;
backtracking[i+1][j+1] = 1;
}
else if(max == up) {
dynamic[i+1][j+1] = up;
backtracking[i+1][j+1] = 2;
}
else if(max == left) {
dynamic[i+1][j+1] = left;
backtracking[i+1][j+1] = 3;
}

if(dynamic[i+1][j+1] > maxvalue) {
maxvalue = dynamic[i+1][j+1];
maxi = i+1;
maxj = j+1;
}
}
}
set->finished = false;
set->x_value = strlen(in);
set->y_value = strlen(sml);
set->min_value = PG_GETARG_INT32(2);
set->max_x = strlen(in);
set->max_y = strlen(sml);
set->dynamic = dynamic;
set->backtracking = backtracking;
set->before = before;

funcctx->user_fctx = set;
MemoryContextSwitchTo(oldcontext);
}

//stuff done on every call of the function
funcctx = SRF_PERCALL_SETUP();

call_cntr = funcctx->call_cntr;
set = funcctx->user_fctx;
x_value = set->x_value;
y_value = set->y_value;
min_value = set->min_value;
max_x = set->max_x;
max_y = set->max_y;
dynamic = set->dynamic;
backtracking = set->backtracking;
before = set->before;

if(!(set->finished)) {
alignres *result;

char *res1 = (char *) palloc((strlen(in)+strlen(sml))*sizeof(char));
char *res2 = (char *) palloc((strlen(in)+strlen(sml))*sizeof(char));

//finds the alignment
int k=0, i=0, j=0, temp_i=0, temp_j=0;
int lengde=0;
bool more = false;
bool first = true;
bool found = false;
for(i=x_value; i>0; i--) {
elog(NOTICE, "found = %d", found);
if(!found) {
for(j=max_y; j>0; j--) {
if(first) {
j=y_value;
first = false;
}
elog(NOTICE, "dynamic[%d][%d]=%d", i, j, dynamic[i][j]);
if(dynamic[i][j] >= min_value && before[i][j] == false) {
before[i][j] = true;
elog(NOTICE, "more");
more = true;
if(j>0) {
set->x_value = i;
set->y_value = j-1;
}
else if(i>0){
set->x_value = i-1;
set->y_value = max_y;
}
else
set->finished = true;
found = true;
temp_i = i;
temp_j = j;
break;
}
}
}
else
break;
}
i = temp_i;
j = temp_j;

while(more)
lengde++;
if(backtracking[i][j]==1) {
res1[k]=in[i-1];
res2[k]=sml[j-1];
i=i-1;
j=j-1;
before[i][j] = true;
}
else if(backtracking[i][j]==2) {
res1[k]=in[i-1];
res2[k]=g[0];
i=i-1;
before[i][j] = true;
}
else if(backtracking[i][j]==3) {
res1[k]=g[0];
res2[k]=sml[j-1];
j=j-1;
before[i][j] = true;
}
else {
more = false;
lengde--;
}
k++;
}
if(backtracking[i][j] > 0) {
if(i != 0)
res1[k]=in[i-1];
else
res1[k]=g[0];
if(j != 0)
res2[k]=sml[j-1];
else
res2[k]=g[0];
lengde++;
}

smst_in = (char*) palloc(1+lengde*sizeof(char));
smst_sml = (char*) palloc(1+lengde*sizeof(char));

i = lengde-1;
j = 0;

while (*(smst_in+j) = *(res1+i)) {
j++;
i--;
}
smst_in[lengde] = '\0';

i = lengde-1;
j = 0;

while (*(smst_sml+j) = *(res2+i)) {
j++;
i--;
}
smst_sml[lengde] = '\0';
elog(NOTICE, "smst_in=%s, smst_sml=%s", smst_in, smst_sml);

result = (alignres *)
palloc(sizeof(*result)+strlen(smst_in)+strlen(smst_sml));
bool first2 = true;
set->finished = true;
for(i=x_value; i>0; i--) {
for(j=max_y; j>0; j--) {
if(first2) {
j=y_value;
first2 = false;
}
if(dynamic[i][j] >= min_value && before[i][j] == false) {
elog(NOTICE, "verdi = %d, setter finished til false", dynamic[i][j]);
set->x_value = i;
set->y_value = j;
set->finished = false;
break;
}
}
}
funcctx->user_fctx = set;
elog(NOTICE, "return next");
SRF_RETURN_NEXT(funcctx, PointerGetDatum(result));
}
else {
elog(NOTICE, "return done");
SRF_RETURN_DONE(funcctx);
}
}