db/migrate/008_remove_segments_helper.cc

   1 #include <mysql.h>
   2 #include <stdint.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <vector>
   7 #include <list>
   8 #include <sstream>
   9 #include <map>
  10 #include <string>
  11
  12 #ifdef __amd64__
  13
  14 #define F_U64 "%lu"
  15 #define F_U32 "%u"
  16
  17 #else
  18
  19 #define F_U64 "%Lu"
  20 #define F_U32 "%u"
  21
  22 #endif
  23
  24 using namespace std;
  25
  26 template <typename T>
  27 static T parse(const char *str) {
  28   istringstream in(str);
  29   T t;
  30   in >> t;
  31   return t;
  32 }
  33
  34 static void exit_mysql_err(MYSQL *mysql) {
  35   const char *err = mysql_error(mysql);
  36   if (err) {
  37     fprintf(stderr, "008_remove_segments_helper: MySQL error: %s\n", err);
  38   } else {
  39     fprintf(stderr, "008_remove_segments_helper: MySQL error\n");
  40   }
  41   abort();
  42   exit(EXIT_FAILURE);
  43 }
  44
  45 static void exit_stmt_err(MYSQL_STMT *stmt) {
  46   const char *err = mysql_stmt_error(stmt);
  47   if (err) {
  48     fprintf(stderr, "008_remove_segments_helper: MySQL stmt error: %s\n", err);
  49   } else {
  50     fprintf(stderr, "008_remove_segments_helper: MySQL stmt error\n");
  51   }
  52   abort();
  53   exit(EXIT_FAILURE);
  54 }
  55
  56 struct segment {
  57   uint32_t from, to;
  58 };
  59
  60 struct data {
  61   MYSQL *mysql, *mysql2;
  62
  63   uint64_t seg_maxid, way_maxid;
  64   uint64_t new_way_id;
  65   uint64_t new_relation_id;
  66
  67   size_t segs_len;
  68   struct segment *segs;
  69   unsigned char *rem_segs;
  70   unsigned char *tgd_segs;
  71
  72   FILE *ways, *way_nodes, *way_tags,
  73     *relations, *relation_members, *relation_tags;
  74 };
  75
  76 static uint64_t select_u64(MYSQL *mysql, const char *q) {
  77   MYSQL_RES *res;
  78   MYSQL_ROW row;
  79   uint64_t ret;
  80
  81   if (mysql_query(mysql, q))
  82     exit_mysql_err(mysql);
  83
  84   res = mysql_store_result(mysql);
  85   if (!res) exit_mysql_err(mysql);
  86
  87   row = mysql_fetch_row(res);
  88   if (!row) exit_mysql_err(mysql);
  89
  90   if (row[0]) {
  91     ret = parse<uint64_t>(row[0]);
  92   } else {
  93     ret = 0;
  94   }
  95
  96   mysql_free_result(res);
  97
  98   return ret;
  99 }
 100
 101 static void find_maxids(struct data *d) {
 102   d->seg_maxid = select_u64(d->mysql, "SELECT max(id) FROM current_segments");
 103   d->segs_len = d->seg_maxid + 1;
 104   d->way_maxid = select_u64(d->mysql, "SELECT max(id) FROM current_ways");
 105   d->new_way_id = d->way_maxid + 1;
 106   d->new_relation_id = select_u64(d->mysql, "SELECT max(id) FROM current_relations") + 1;
 107 }
 108
 109 static void populate_segs(struct data *d) {
 110   MYSQL_RES *res;
 111   MYSQL_ROW row;
 112   size_t id;
 113
 114   d->segs = (segment *) malloc(sizeof(struct segment) * d->segs_len);
 115   memset(d->segs, 0, sizeof(struct segment) * d->segs_len);
 116
 117   d->rem_segs = (unsigned char *) malloc(d->segs_len);
 118   d->tgd_segs = (unsigned char *) malloc(d->segs_len);
 119   memset(d->rem_segs, 0, d->segs_len);
 120   memset(d->tgd_segs, 0, d->segs_len);
 121
 122   if (mysql_query(d->mysql, "SELECT id, node_a, node_b "
 123       "FROM current_segments WHERE visible"))
 124     exit_mysql_err(d->mysql);
 125
 126   res = mysql_use_result(d->mysql);
 127   if (!res) exit_mysql_err(d->mysql);
 128
 129   while ((row = mysql_fetch_row(res))) {
 130     id = parse<size_t>(row[0]);
 131     if (id >= d->segs_len) continue;
 132     d->segs[id].from = parse<uint32_t>(row[1]);
 133     d->segs[id].to   = parse<uint32_t>(row[2]);
 134     d->rem_segs[id] = 1;
 135   }
 136   if (mysql_errno(d->mysql)) exit_mysql_err(d->mysql);
 137
 138   mysql_free_result(res);
 139 }
 140
 141 static void write_csv_col(FILE *f, const char *str, char end) {
 142   char *out = (char *) malloc(2 * strlen(str) + 4);
 143   char *o = out;
 144   size_t len;
 145
 146   *(o++) = '\"';
 147   for (; *str; str++) {
 148     if (*str == '\0') {
 149       break;
 150     } else if (*str == '\"') {
 151       *(o++) = '\"';
 152       *(o++) = '\"';
 153     } else {
 154       *(o++) = *str;
 155     }
 156   }
 157   *(o++) = '\"';
 158   *(o++) = end;
 159   *(o++) = '\0';
 160
 161   len = strlen(out);
 162   if (fwrite(out, len, 1, f) != 1) {
 163     perror("fwrite");
 164     exit(EXIT_FAILURE);
 165   }
 166
 167   free(out);
 168 }
 169
 170 static void convert_ways(struct data *d) {
 171   MYSQL_RES *res;
 172   MYSQL_ROW row;
 173   MYSQL_STMT *load_segs, *load_tags;
 174   const char
 175     load_segs_stmt[] = "SELECT segment_id FROM current_way_segments "
 176       "WHERE id = ? ORDER BY sequence_id",
 177     load_tags_stmt[] = "SELECT k, v FROM current_way_tags WHERE id = ?";
 178   char *k, *v;
 179   const size_t max_tag_len = 1 << 16;
 180   long long mysql_id, mysql_seg_id;
 181   unsigned long res_len;
 182   my_bool res_error;
 183   MYSQL_BIND bind[1], seg_bind[1], tag_bind[2];
 184
 185   /* F***ing libmysql only support fixed size buffers for string results of
 186    * prepared statements.  So allocate 65k for the tag key and the tag value
 187    * and hope it'll suffice. */
 188   k = (char *) malloc(max_tag_len);
 189   v = (char *) malloc(max_tag_len);
 190
 191   load_segs = mysql_stmt_init(d->mysql2);
 192   if (!load_segs) exit_mysql_err(d->mysql2);
 193   if (mysql_stmt_prepare(load_segs, load_segs_stmt, sizeof(load_segs_stmt)))
 194     exit_stmt_err(load_segs);
 195
 196   memset(bind, 0, sizeof(bind));
 197   bind[0].buffer_type = MYSQL_TYPE_LONGLONG;
 198   bind[0].buffer = (char *) &mysql_id;
 199   bind[0].is_null = 0;
 200   bind[0].length = 0;
 201   if (mysql_stmt_bind_param(load_segs, bind))
 202     exit_stmt_err(load_segs);
 203
 204   memset(seg_bind, 0, sizeof(seg_bind));
 205   seg_bind[0].buffer_type = MYSQL_TYPE_LONGLONG;
 206   seg_bind[0].buffer = (char *) &mysql_seg_id;
 207   seg_bind[0].is_null = 0;
 208   seg_bind[0].length = 0;
 209   seg_bind[0].error = &res_error;
 210   if (mysql_stmt_bind_result(load_segs, seg_bind))
 211     exit_stmt_err(load_segs);
 212
 213   load_tags = mysql_stmt_init(d->mysql2);
 214   if (!load_tags) exit_mysql_err(d->mysql2);
 215   if (mysql_stmt_prepare(load_tags, load_tags_stmt, sizeof(load_tags_stmt)))
 216     exit_stmt_err(load_tags);
 217
 218   memset(bind, 0, sizeof(bind));
 219   bind[0].buffer_type = MYSQL_TYPE_LONGLONG;
 220   bind[0].buffer = (char *) &mysql_id;
 221   bind[0].is_null = 0;
 222   bind[0].length = 0;
 223
 224   if (mysql_stmt_bind_param(load_tags, bind))
 225     exit_stmt_err(load_tags);
 226
 227   memset(tag_bind, 0, sizeof(tag_bind));
 228   tag_bind[0].buffer_type = MYSQL_TYPE_STRING;
 229   tag_bind[0].buffer = k;
 230   tag_bind[0].is_null = 0;
 231   tag_bind[0].length = &res_len;
 232   tag_bind[0].error = &res_error;
 233   tag_bind[0].buffer_length = max_tag_len;
 234   tag_bind[1].buffer_type = MYSQL_TYPE_STRING;
 235   tag_bind[1].buffer = v;
 236   tag_bind[1].is_null = 0;
 237   tag_bind[1].length = &res_len;
 238   tag_bind[1].error = &res_error;
 239   tag_bind[1].buffer_length = max_tag_len;
 240   if (mysql_stmt_bind_result(load_tags, tag_bind))
 241     exit_stmt_err(load_tags);
 242
 243   if (mysql_query(d->mysql, "SELECT id, user_id, timestamp "
 244       "FROM current_ways WHERE visible"))
 245     exit_mysql_err(d->mysql);
 246
 247   res = mysql_use_result(d->mysql);
 248   if (!res) exit_mysql_err(d->mysql);
 249
 250   while ((row = mysql_fetch_row(res))) {
 251     uint64_t id;
 252     const char *user_id, *timestamp;
 253
 254     id = parse<uint64_t>(row[0]);
 255     user_id = row[1];
 256     timestamp = row[2];
 257
 258     mysql_id = (long long) id;
 259
 260     if (mysql_stmt_execute(load_segs))
 261       exit_stmt_err(load_segs);
 262
 263     if (mysql_stmt_store_result(load_segs))
 264       exit_stmt_err(load_segs);
 265
 266     list<segment> segs;
 267     while (!mysql_stmt_fetch(load_segs)) {
 268       if (((uint64_t) mysql_seg_id) >= d->segs_len) continue;
 269       segs.push_back(d->segs[mysql_seg_id]);
 270       d->rem_segs[mysql_seg_id] = 0;
 271     }
 272
 273     list<list<uint32_t> > node_lists;
 274     while (segs.size()) {
 275       list<uint32_t> node_list;
 276       node_list.push_back(segs.front().from);
 277       node_list.push_back(segs.front().to);
 278       segs.pop_front();
 279       while (true) {
 280         bool found = false;
 281         for (list<segment>::iterator it = segs.begin();
 282             it != segs.end(); ) {
 283           if (it->from == node_list.back()) {
 284             node_list.push_back(it->to);
 285             segs.erase(it++);
 286             found = true;
 287           } else if (it->to == node_list.front()) {
 288             node_list.insert(node_list.begin(), it->from);
 289             segs.erase(it++);
 290             found = true;
 291           } else {
 292             ++it;
 293           }
 294         }
 295         if (!found) break;
 296       }
 297       node_lists.push_back(node_list);
 298     }
 299
 300     vector<uint64_t> ids; ids.reserve(node_lists.size());
 301     bool orig_id_used = false;
 302     for (list<list<uint32_t> >::iterator it = node_lists.begin();
 303         it != node_lists.end(); ++it) {
 304       uint64_t way_id;
 305       int sid;
 306       if (orig_id_used) {
 307         way_id = d->new_way_id++;
 308       } else {
 309         way_id = id;
 310         orig_id_used = true;
 311       }
 312       ids.push_back(way_id);
 313
 314       fprintf(d->ways, "\"" F_U64 "\",", way_id);
 315       write_csv_col(d->ways, user_id, ',');
 316       write_csv_col(d->ways, timestamp, '\n');
 317
 318       sid = 1;
 319       for (list<uint32_t>::iterator nit = it->begin();
 320           nit != it->end(); ++nit) {
 321         fprintf(d->way_nodes, "\"" F_U64 "\",\"" F_U32 "\",\"%i\"\n", way_id, *nit, sid++);
 322       }
 323     }
 324
 325     if (mysql_stmt_execute(load_tags))
 326       exit_stmt_err(load_tags);
 327
 328     if (mysql_stmt_store_result(load_tags))
 329       exit_stmt_err(load_tags);
 330
 331     bool multiple_parts = ids.size() > 1,
 332       create_multipolygon = false;
 333
 334     while (!mysql_stmt_fetch(load_tags)) {
 335       if (multiple_parts && !create_multipolygon) {
 336         if (!strcmp(k, "natural")) {
 337           if (strcmp(v, "coastline")) {
 338             create_multipolygon = true;
 339           }
 340         } else if (!strcmp(k, "waterway")) {
 341           if (!strcmp(v, "riverbank")) {
 342             create_multipolygon = true;
 343           }
 344         } else if (!strcmp(k, "leisure") || !strcmp(k, "landuse")
 345             || !strcmp(k, "sport") || !strcmp(k, "amenity")
 346             || !strcmp(k, "tourism") || !strcmp(k, "building")) {
 347           create_multipolygon = true;
 348         }
 349       }
 350
 351       for (vector<uint64_t>::iterator it = ids.begin();
 352           it != ids.end(); ++it) {
 353         fprintf(d->way_tags, "\"" F_U64 "\",", *it);
 354         write_csv_col(d->way_tags, k, ',');
 355         write_csv_col(d->way_tags, v, '\n');
 356       }
 357     }
 358
 359     if (multiple_parts && create_multipolygon) {
 360       uint64_t ent_id = d->new_relation_id++;
 361
 362       fprintf(d->relations, "\"" F_U64 "\",", ent_id);
 363       write_csv_col(d->relations, user_id, ',');
 364       write_csv_col(d->relations, timestamp, '\n');
 365
 366       fprintf(d->relation_tags,
 367         "\"" F_U64 "\",\"type\",\"multipolygon\"\n", ent_id);
 368
 369       for (vector<uint64_t>::iterator it = ids.begin();
 370           it != ids.end(); ++it) {
 371         fprintf(d->relation_members,
 372           "\"" F_U64 "\",\"way\",\"" F_U64 "\",\"\"\n", ent_id, *it);
 373       }
 374     }
 375   }
 376   if (mysql_errno(d->mysql)) exit_stmt_err(load_tags);
 377
 378   mysql_stmt_close(load_segs);
 379   mysql_stmt_close(load_tags);
 380
 381   mysql_free_result(res);
 382   free(k);
 383   free(v);
 384 }
 385
 386 static int read_seg_tags(char **tags, char **k, char **v) {
 387   if (!**tags) return 0;
 388   char *i = strchr(*tags, ';');
 389   if (!i) i = *tags + strlen(*tags);
 390   char *j = strchr(*tags, '=');
 391   *k = *tags;
 392   if (j && j < i) {
 393     *v = j + 1;
 394   } else {
 395     *v = i;
 396   }
 397   *tags = *i ? i + 1 : i;
 398   *i = '\0';
 399   if (j) *j = '\0';
 400   return 1;
 401 }
 402
 403 static void mark_tagged_segs(struct data *d) {
 404   MYSQL_RES *res;
 405   MYSQL_ROW row;
 406   MYSQL_STMT *way_tags;
 407   const char
 408     way_tags_stmt[] = "SELECT k, v FROM current_way_segments INNER JOIN "
 409       "current_way_tags ON current_way_segments.id = "
 410       "current_way_tags.id WHERE segment_id = ?";
 411   char *wk, *wv;
 412   const size_t max_tag_len = 1 << 16;
 413   long long mysql_seg_id;
 414   unsigned long res_len;
 415   my_bool res_error;
 416   MYSQL_BIND in_bind[1], out_bind[1];
 417
 418   /* F***ing libmysql only support fixed size buffers for string results of
 419    * prepared statements.  So allocate 65k for the tag key and the tag value
 420    * and hope it'll suffice. */
 421   wk = (char *) malloc(max_tag_len);
 422   wv = (char *) malloc(max_tag_len);
 423
 424   way_tags = mysql_stmt_init(d->mysql2);
 425   if (!way_tags) exit_mysql_err(d->mysql2);
 426   if (mysql_stmt_prepare(way_tags, way_tags_stmt, sizeof(way_tags_stmt)))
 427     exit_stmt_err(way_tags);
 428
 429   memset(in_bind, 0, sizeof(in_bind));
 430   in_bind[0].buffer_type = MYSQL_TYPE_LONGLONG;
 431   in_bind[0].buffer = (char *) &mysql_seg_id;
 432   in_bind[0].is_null = 0;
 433   in_bind[0].length = 0;
 434
 435   if (mysql_stmt_bind_param(way_tags, in_bind))
 436     exit_stmt_err(way_tags);
 437
 438   memset(out_bind, 0, sizeof(out_bind));
 439   out_bind[0].buffer_type = MYSQL_TYPE_STRING;
 440   out_bind[0].buffer = wk;
 441   out_bind[0].is_null = 0;
 442   out_bind[0].length = &res_len;
 443   out_bind[0].error = &res_error;
 444   out_bind[0].buffer_length = max_tag_len;
 445   out_bind[1].buffer_type = MYSQL_TYPE_STRING;
 446   out_bind[1].buffer = wv;
 447   out_bind[1].is_null = 0;
 448   out_bind[1].length = &res_len;
 449   out_bind[1].error = &res_error;
 450   out_bind[1].buffer_length = max_tag_len;
 451   if (mysql_stmt_bind_result(way_tags, out_bind))
 452     exit_stmt_err(way_tags);
 453
 454   if (mysql_query(d->mysql, "SELECT id, tags FROM current_segments "
 455       "WHERE visible && tags != '' && tags != 'created_by=JOSM'"))
 456     exit_mysql_err(d->mysql);
 457
 458   res = mysql_use_result(d->mysql);
 459   if (!res) exit_mysql_err(d->mysql);
 460
 461   while ((row = mysql_fetch_row(res))) {
 462     size_t id = parse<size_t>(row[0]);
 463     if (d->rem_segs[id]) continue;
 464
 465     map<string, string> interesting_tags;
 466
 467     char *tags_it = row[1], *k, *v;
 468     while (read_seg_tags(&tags_it, &k, &v)) {
 469       if (strcmp(k, "created_by") &&
 470           strcmp(k, "tiger:county") &&
 471           strcmp(k, "tiger:upload_uuid") &&
 472           strcmp(k, "converted_by") &&
 473           (strcmp(k, "width") || strcmp(v, "4")) &&
 474           (strcmp(k, "natural") || strcmp(v, "coastline")) &&
 475           (strcmp(k, "source") || strncmp(v, "PGS", 3))) {
 476         interesting_tags.insert(make_pair(string(k), string(v)));
 477       }
 478     }
 479
 480     if (interesting_tags.size() == 0) continue;
 481
 482     mysql_seg_id = id;
 483
 484     if (mysql_stmt_execute(way_tags))
 485       exit_stmt_err(way_tags);
 486
 487     if (mysql_stmt_store_result(way_tags))
 488       exit_stmt_err(way_tags);
 489
 490     while (!mysql_stmt_fetch(way_tags)) {
 491       for (map<string, string>::iterator it = interesting_tags.find(wk);
 492           it != interesting_tags.end() && it->first == wk; ++it) {
 493         if (it->second == wv) {
 494           interesting_tags.erase(it);
 495           break;
 496         }
 497       }
 498     }
 499
 500     if (interesting_tags.size() > 0) {
 501       d->rem_segs[id] = 1;
 502       d->tgd_segs[id] = 1;
 503     }
 504   }
 505
 506   mysql_free_result(res);
 507
 508   mysql_stmt_close(way_tags);
 509   free(wk);
 510   free(wv);
 511 }
 512
 513 static void convert_remaining_segs(struct data *d) {
 514   MYSQL_STMT *load_seg;
 515   MYSQL_BIND args[1], res[3];
 516   const size_t max_tag_len = 1 << 16;
 517   char *tags, timestamp[100];
 518   char *k, *v;
 519   char notetmp[1024];
 520   int user_id;
 521   long long mysql_id;
 522   unsigned long res_len;
 523   my_bool res_error;
 524   const char load_seg_stmt[] =
 525     "SELECT user_id, tags, CAST(timestamp AS CHAR) FROM current_segments "
 526     "WHERE visible && id = ?";
 527
 528   tags = (char *) malloc(max_tag_len);
 529
 530   load_seg = mysql_stmt_init(d->mysql);
 531   if (!load_seg) exit_mysql_err(d->mysql);
 532   if (mysql_stmt_prepare(load_seg, load_seg_stmt, sizeof(load_seg_stmt)))
 533     exit_stmt_err(load_seg);
 534
 535   memset(args, 0, sizeof(args));
 536   args[0].buffer_type = MYSQL_TYPE_LONGLONG;
 537   args[0].buffer = (char *) &mysql_id;
 538   args[0].is_null = 0;
 539   args[0].length = 0;
 540   if (mysql_stmt_bind_param(load_seg, args))
 541     exit_stmt_err(load_seg);
 542
 543   memset(res, 0, sizeof(res));
 544   res[0].buffer_type = MYSQL_TYPE_LONG;
 545   res[0].buffer = (char *) &user_id;
 546   res[0].is_null = 0;
 547   res[0].length = 0;
 548   res[0].error = &res_error;
 549   res[1].buffer_type = MYSQL_TYPE_STRING;
 550   res[1].buffer = tags;
 551   res[1].is_null = 0;
 552   res[1].length = &res_len;
 553   res[1].error = &res_error;
 554   res[1].buffer_length = max_tag_len;
 555   res[2].buffer_type = MYSQL_TYPE_STRING;
 556   res[2].buffer = timestamp;
 557   res[2].is_null = 0;
 558   res[2].length = &res_len;
 559   res[2].error = &res_error;
 560   res[2].buffer_length = sizeof(timestamp);
 561   if (mysql_stmt_bind_result(load_seg, res))
 562     exit_stmt_err(load_seg);
 563
 564   for (size_t seg_id = 0; seg_id < d->segs_len; seg_id++) {
 565     if (!d->rem_segs[seg_id]) continue;
 566     const char *what = d->tgd_segs[seg_id] ? "tagged" : "unwayed";
 567     segment seg = d->segs[seg_id];
 568
 569     mysql_id = seg_id;
 570     if (mysql_stmt_execute(load_seg)) exit_stmt_err(load_seg);
 571     if (mysql_stmt_store_result(load_seg)) exit_stmt_err(load_seg);
 572
 573     while (!mysql_stmt_fetch(load_seg)) {
 574       uint64_t way_id = d->new_way_id++;
 575
 576       fprintf(d->ways, "\"" F_U64 "\",\"%i\",", way_id, user_id);
 577       write_csv_col(d->ways, timestamp, '\n');
 578
 579       fprintf(d->way_nodes, "\"" F_U64 "\",\"" F_U32 "\",\"%i\"\n", way_id, seg.from, 1);
 580       fprintf(d->way_nodes, "\"" F_U64 "\",\"" F_U32 "\",\"%i\"\n", way_id, seg.to, 2);
 581
 582       char *tags_it = tags;
 583       bool note = false;
 584       while (read_seg_tags(&tags_it, &k, &v)) {
 585         fprintf(d->way_tags, "\"" F_U64 "\",", way_id);
 586         write_csv_col(d->way_tags, k, ',');
 587         if(!strcmp(k,"note")) {
 588           snprintf(notetmp, sizeof(notetmp), "%s; FIXME previously %s segment", v, what);
 589           note = true;
 590           write_csv_col(d->way_tags, notetmp, '\n');
 591         } else {
 592           write_csv_col(d->way_tags, v, '\n');
 593         }
 594       }
 595       if (!note) {
 596         sprintf(notetmp, "FIXME previously %s segment", what);
 597         fprintf(d->way_tags, "\"" F_U64 "\",", way_id);
 598         write_csv_col(d->way_tags, "note", ',');
 599         write_csv_col(d->way_tags, notetmp, '\n');
 600       }
 601     }
 602   }
 603
 604   mysql_stmt_close(load_seg);
 605
 606   free(tags);
 607 }
 608
 609 static MYSQL *connect_to_mysql(char **argv) {
 610   MYSQL *mysql = mysql_init(NULL);
 611   if (!mysql) exit_mysql_err(mysql);
 612
 613   if (!mysql_real_connect(mysql, argv[1], argv[2], argv[3], argv[4],
 614       argv[5][0] ? atoi(argv[5]) : 0, argv[6][0] ? argv[6] : NULL, 0))
 615     exit_mysql_err(mysql);
 616
 617   if (mysql_set_character_set(mysql, "utf8"))
 618     exit_mysql_err(mysql);
 619
 620   return mysql;
 621 }
 622
 623 static void open_file(FILE **f, char *fn) {
 624   *f = fopen(fn, "w+");
 625   if (!*f) {
 626     perror("fopen");
 627     exit(EXIT_FAILURE);
 628   }
 629 }
 630
 631 int main(int argc, char **argv) {
 632   struct data data;
 633   struct data *d = &data;
 634   size_t prefix_len;
 635   char *tempfn;
 636
 637   if (argc != 8) {
 638     printf("Usage: 008_remove_segments_helper host user passwd database port socket prefix\n");
 639     exit(EXIT_FAILURE);
 640   }
 641
 642   d->mysql = connect_to_mysql(argv);
 643   d->mysql2 = connect_to_mysql(argv);
 644
 645   prefix_len = strlen(argv[7]);
 646   tempfn = (char *) malloc(prefix_len + 15);
 647   strcpy(tempfn, argv[7]);
 648
 649   strcpy(tempfn + prefix_len, "ways");
 650   open_file(&d->ways, tempfn);
 651
 652   strcpy(tempfn + prefix_len, "way_nodes");
 653   open_file(&d->way_nodes, tempfn);
 654
 655   strcpy(tempfn + prefix_len, "way_tags");
 656   open_file(&d->way_tags, tempfn);
 657
 658   strcpy(tempfn + prefix_len, "relations");
 659   open_file(&d->relations, tempfn);
 660
 661   strcpy(tempfn + prefix_len, "relation_members");
 662   open_file(&d->relation_members, tempfn);
 663
 664   strcpy(tempfn + prefix_len, "relation_tags");
 665   open_file(&d->relation_tags, tempfn);
 666
 667   free(tempfn);
 668
 669   find_maxids(d);
 670   populate_segs(d);
 671   convert_ways(d);
 672   mark_tagged_segs(d);
 673   convert_remaining_segs(d);
 674
 675   mysql_close(d->mysql);
 676   mysql_close(d->mysql2);
 677
 678   fclose(d->ways);
 679   fclose(d->way_nodes);
 680   fclose(d->way_tags);
 681
 682   fclose(d->relations);
 683   fclose(d->relation_members);
 684   fclose(d->relation_tags);
 685
 686   free(d->segs);
 687   free(d->rem_segs);
 688   free(d->tgd_segs);
 689
 690   exit(EXIT_SUCCESS);
 691 }