pgRouting

Changeset 160

Show
Ignore:
Timestamp:
04/07/08 14:14:31 (8 months ago)
Author:
anton
Message:

Test commit for 'Start edge not found' error

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/core/src/shooting_star.c

    r148 r160  
    189189  int t; 
    190190 
    191   DBG("fetching\n"); 
    192  
    193191  for(t=0; t<MAX_RULE_LENGTH;++t) 
    194192    target_edge->rule[t] = -1; 
    195193     
    196   DBG("rule reset\n"); 
    197  
    198194  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->id, &isnull); 
    199195  if (isnull) 
    200196    elog(ERROR, "id contains a null value"); 
    201197  target_edge->id = DatumGetInt32(binval); 
    202   DBG("id: %i\n", target_edge->id); 
    203198   
    204199  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->source, &isnull); 
    …… 
    206201    elog(ERROR, "source contains a null value"); 
    207202  target_edge->source = DatumGetInt32(binval); 
    208   DBG("source: %i\n", target_edge->source); 
    209203 
    210204  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->target, &isnull); 
    …… 
    212206    elog(ERROR, "target contains a null value"); 
    213207  target_edge->target = DatumGetInt32(binval); 
    214   DBG("target: %i\n", target_edge->target); 
    215208 
    216209  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->cost, &isnull); 
    …… 
    218211    elog(ERROR, "cost contains a null value"); 
    219212  target_edge->cost = DatumGetFloat8(binval); 
    220   DBG("cost: %f\n", target_edge->cost); 
    221213 
    222214  if (edge_columns->reverse_cost != -1)  
    …… 
    227219        elog(ERROR, "reverse_cost contains a null value"); 
    228220      target_edge->reverse_cost =  DatumGetFloat8(binval); 
    229       DBG("r_cost: %f\n", target_edge->reverse_cost); 
    230  
    231221    } 
    232222 
    …… 
    235225    elog(ERROR, "source x contains a null value"); 
    236226  target_edge->s_x = DatumGetFloat8(binval); 
    237   DBG("s_x: %f\n", target_edge->s_x); 
    238227 
    239228  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->s_y, &isnull); 
    …… 
    241230    elog(ERROR, "source y contains a null value"); 
    242231  target_edge->s_y = DatumGetFloat8(binval); 
    243   DBG("s_y: %f\n", target_edge->s_y); 
    244232   
    245233  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->t_x, &isnull); 
    …… 
    247235    elog(ERROR, "target x contains a null value"); 
    248236  target_edge->t_x = DatumGetFloat8(binval); 
    249   DBG("t_x: %f\n", target_edge->t_x); 
    250237   
    251238  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->t_y, &isnull); 
    …… 
    253240    elog(ERROR, "target y contains a null value"); 
    254241  target_edge->t_y = DatumGetFloat8(binval); 
    255   DBG("t_y: %f\n", target_edge->t_y); 
    256242 
    257243  binval = SPI_getbinval(*tuple, *tupdesc, edge_columns->to_cost, &isnull); 
    258244  if (isnull) 
    259     target_edge->to_cost = 0;     
     245    target_edge->to_cost = 0; 
     246     
    260247  else 
    261248    target_edge->to_cost = DatumGetFloat8(binval); 
    262   DBG("to_cost: %f\n", target_edge->to_cost); 
    263249 
    264250  char *str = DatumGetCString(SPI_getvalue(*tuple, *tupdesc, edge_columns->rule)); 
    265    
    266   if(str != NULL) 
     251 
     252  if(str!=NULL) 
    267253  { 
    268   char *str2 = " rule loaded\n"; 
    269   char *str3; 
    270    
    271   str3 = (char *)calloc(strlen(str) + strlen(str2) + 1, sizeof(char)); 
    272   strcat(str3, str); 
    273   strcat(str3, str2);   
    274    
    275   DBG(str3); 
    276    
    277   free(str3); 
    278  
    279   char* pch = NULL; 
    280   int ci = MAX_RULE_LENGTH; 
    281  
    282   pch = strtok (str," ,"); 
    283    
    284   DBG("parsing rule\n"); 
    285   while (pch != NULL) 
    286   { 
    287     --ci; 
    288     target_edge->rule[ci] = atoi(pch); 
    289     pch = (char *)strtok (NULL, " ,"); 
    290   } 
    291   DBG("rule: %i\n", target_edge->rule[0]); 
     254    char* pch = NULL; 
     255    int ci = MAX_RULE_LENGTH; 
     256 
     257    pch = (char *)strtok (str," ,"); 
     258   
     259    while (pch != NULL) 
     260    { 
     261      --ci; 
     262      target_edge->rule[ci] = atoi(pch); 
     263      pch = (char *)strtok (NULL, " ,"); 
     264    } 
    292265  } 
    293266} 
    …… 
    358331        } 
    359332         
    360 //     DBG("***%i***", ret); 
     333       //DBG("***%i***", ret); 
    361334 
    362335      ntuples = SPI_processed; 
    363       DBG("ntuples = %i", ntuples); 
    364  
    365336      total_tuples += ntuples; 
    366       DBG("<%i> tuples", total_tuples); 
    367  
    368 //      if (!edges) 
    369       if (total_tuples <= TUPLIMIT) 
     337 
     338      if (!edges) 
    370339        edges = palloc(total_tuples * sizeof(edge_shooting_star_t)); 
    371340      else 
    …… 
    373342 
    374343      if (edges == NULL)  
    375       { 
    376         elog(ERROR, "Out of memory"); 
    377         return finish(SPIcode, ret); 
    378       } 
     344        { 
     345          elog(ERROR, "Out of memory"); 
     346          return finish(SPIcode, ret); 
     347        } 
    379348 
    380349      if (ntuples > 0)  
    381       { 
     350        { 
    382351          int t; 
    383352          SPITupleTable *tuptable = SPI_tuptable; 
    384353          TupleDesc tupdesc = SPI_tuptable->tupdesc; 
    385  
     354           
    386355          for (t = 0; t < ntuples; t++)  
    387           { 
    388             HeapTuple tuple = tuptable->vals[t]; 
    389             fetch_edge_shooting_star(&tuple, &tupdesc, &edge_columns,  
     356            { 
     357              HeapTuple tuple = tuptable->vals[t]; 
     358              fetch_edge_shooting_star(&tuple, &tupdesc, &edge_columns,  
    390359                               &edges[total_tuples - ntuples + t]); 
    391                                 
    392             DBG("edges[%i].id = %i", total_tuples - ntuples + t, edges[total_tuples - ntuples + t].id); 
    393  
    394     if(edges[total_tuples - ntuples + t].id<e_min_id) 
    395       e_min_id=edges[total_tuples - ntuples + t].id; 
    396  
    397     if(edges[total_tuples - ntuples + t].id>e_max_id) 
    398       e_max_id=edges[total_tuples - ntuples + t].id; 
    399              
    400  
    401     if(edges[total_tuples - ntuples + t].id == source_edge_id) 
    402       ++s_count; 
    403     if(edges[total_tuples - ntuples + t].id == target_edge_id) 
    404       ++t_count; 
    405  
    406           } 
     360            } 
    407361          SPI_freetuptable(tuptable); 
    408       }  
     362        }  
    409363      else  
    410       { 
     364        { 
    411365          moredata = FALSE; 
    412       } 
    413     } 
    414      
    415        
    416   DBG("Total <%i> tuples", total_tuples); 
    417  
    418      
    419 /* 
     366        } 
     367    } 
     368     
     369       
     370  DBG("Total %i tuples", total_tuples); 
     371 
     372     
     373 
    420374  for(z=0; z<total_tuples; z++) 
    421375  { 
    …… 
    427381 
    428382  } 
    429 */ 
     383 
    430384    DBG("E : %i <-> %i", e_min_id, e_max_id); 
    431385 
    432   //for(z=0; z<total_tuples; ++z) 
    433   //{ 
     386  for(z=0; z<total_tuples; ++z) 
     387  { 
    434388 
    435389    //check if edges[] contains source and target 
    436      
    437   //DBG("edges[%i].id (%i) == %i", z, edges[z].id, source_edge_id); 
    438  
    439 /*     
    440     if(edges[z].id == source_edge_id) 
     390    if(edges[z].id == source_edge_id ||  
     391       edges[z].id == source_edge_id) 
    441392      ++s_count; 
    442     if(edges[z].id == target_edge_id) 
     393    if(edges[z].id == target_edge_id ||  
     394       edges[z].id == target_edge_id) 
    443395      ++t_count; 
    444 */ 
     396 
    445397 
    446398    //edges[z].source-=v_min_id; 
    447399    //edges[z].target-=v_min_id; 
    448400     
    449   //} 
    450      
    451   //DBG("Total %i tuples", total_tuples); 
     401  } 
     402     
     403  DBG("Total %i tuples", total_tuples); 
    452404 
    453405  if(s_count == 0) 
    …… 
    469421  //time_t stime = time(NULL);     
    470422 
    471   DBG("ret =  %i\n",ret); 
    472  
    473423  ret = boost_shooting_star(edges, total_tuples, source_edge_id,  
    474424                    target_edge_id, 
    …… 
    489439      ereport(ERROR, (errcode(ERRCODE_E_R_E_CONTAINING_SQL_NOT_PERMITTED),  
    490440        errmsg("Error computing path: %s", err_msg))); 
    491 //        errmsg("Error computing path: %i", ret))); 
    492441    }  
    493442  return finish(SPIcode, ret);