source: subversion/applications/utils/export/osm2poidb/osm2poidb.c @ 34613

Last change on this file since 34613 was 20375, checked in by guenther, 10 years ago
  • optimized indexes
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/plain
File size: 20.3 KB
Line 
1/***********************************************************************
2gpsdrive-update-osm-poi-db
3
4    creates and fills an sqlite database file (osm.db) for storage
5    of POI data from an osm xml file, matching gpsdrive poi_types
6    with osm types.
7
8Copyright (c) 2008 Guenther Meyer <d.s.e (at) sordidmusic.com>
9
10Website: www.gpsdrive.de
11
12Disclaimer: Please do not use for navigation.
13
14    This program is free software; you can redistribute it and/or modify
15    it under the terms of the GNU General Public License as published by
16    the Free Software Foundation.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26
27*********************************************************************/
28
29
30#include <stdlib.h>
31#include <glib.h>
32#include <glib/gstdio.h>
33#include <locale.h>
34#include <string.h>
35#include <sqlite3.h>
36#include <libxml/xmlreader.h>
37#include <signal.h>
38#include <unistd.h>
39
40
41#define DB_GEOINFO "/usr/share/gpsdrive/geoinfo.db"
42#define DB_OSMFILE "./osm.db"
43#define MAX_TAGS_PER_NODE 10
44
45#define PGM_VERSION "0.3"
46
47
48
49
50sqlite3 *geoinfo_db, *osm_db;
51sqlite3_stmt *ppStmt;
52gint status = 0;
53gchar *error_string;
54gulong count = 0;
55gulong node_count = 0;
56gulong poi_count = 0;
57gboolean show_version = FALSE;
58gboolean verbose = FALSE;
59gboolean stop_on_way = FALSE;
60gboolean nodes_done = FALSE;
61gboolean parsing_active = FALSE;
62gint spinpos = 0;
63GHashTable *poitypes_hash;
64xmlTextReaderPtr xml_reader;
65const gchar *spinner = "|/-\\";
66
67typedef struct
68{
69        gulong id;
70        gdouble lat;
71        gdouble lon;
72        gchar key[MAX_TAGS_PER_NODE][255];
73        gchar value[MAX_TAGS_PER_NODE][255];
74        gchar poi_type[160];
75        gchar name[80];
76        guint tag_count;
77}
78node_struct;
79
80
81/* ******************************************************************
82 * escape special characters in sql string.
83 * returned string has to be freed after usage!
84 */
85gchar
86*escape_sql_string (const gchar *data)
87{
88        gint i, j, length;
89        gchar *tdata = NULL;
90
91        length = strlen (data);
92        tdata = g_malloc (length*2 + 1);
93        j = 0;
94        for (i = 0; i <= length; i++)
95        {
96                if (data[i] == '\'')
97                        tdata[j++] = '\'';
98                tdata[j++] = data[i];
99        }
100
101        //g_print ("=== %s === %s ===\n", data, tdata);
102
103        return tdata;
104}
105
106
107/* *****************************************************************************
108 * callback for reading poi_types from geoinfo.db
109 */
110gint
111read_poi_types_cb (gpointer datum, gint columns, gchar **values, gchar **names)
112{
113        gchar *t_osm, *t_poi;
114
115        t_osm = g_strdup (values[0]);
116        t_poi = g_strdup (values[1]);
117        g_hash_table_insert (poitypes_hash, t_osm, t_poi);
118
119        if (verbose)
120                g_print ("    %s\t--->\t%s\t\n", t_osm, t_poi);
121
122        return 0;
123}
124
125
126/* *****************************************************************************
127 * callback for matching 2nd and 3rd level osm tags to gpsdrive poi_types
128 */
129gint
130match_types_osm_fine_cb (gpointer datum, gint columns, gchar **values, gchar **names)
131{
132        gint t_res = 0;
133        gchar *t_query;
134        gchar **t_buf;
135        gchar *t_buf1;
136
137        t_buf = g_strsplit (values[1], "=", 2);
138        t_buf1 = escape_sql_string (t_buf[1]);
139        if (strcmp ("name", t_buf[0]) == 0)
140        {
141                t_query = g_strdup_printf ("UPDATE poi SET poi_type='%s' WHERE name LIKE '%s';",
142                        values[0], t_buf1);
143        }
144        else
145        {
146                t_query = g_strdup_printf ("UPDATE poi SET poi_type='%s' WHERE poi_id IN"
147                        " (SELECT poi_id FROM poi_extra WHERE field_name='%s' AND entry LIKE '%s');",
148                        values[0], t_buf[0], t_buf1);
149        }
150        g_free (t_buf1);
151
152        if (verbose)
153                g_print ("    %s\t--->\t%s\t\n", values[1], values[0]);
154
155        //g_print ("SQL-Query: %s\n", t_query);
156
157        t_res = sqlite3_exec (osm_db, t_query, NULL, NULL, &error_string);
158        if (t_res != SQLITE_OK )
159        {
160                g_print ("  SQLite error: %s\n", error_string);
161                sqlite3_free(error_string);
162                exit (EXIT_FAILURE);
163        }
164
165        g_free (t_query);
166        g_strfreev (t_buf);
167
168        return 0;
169}
170
171
172/* *****************************************************************************
173 * add new POI to database
174 */
175void
176add_new_poi (node_struct *data)
177{
178        gchar query[500];
179        guint i = 0;
180        gulong t_id;
181        gchar *t_buf3, *t_buf4;
182
183        if (verbose)
184        {
185                g_print ("\n    |  id = %u\t%.6f / %.6f\n    |  poi_type = %s\n"
186                        "    |  name = %s\n", (unsigned int) data->id, data->lat, data->lon,
187                        data->poi_type, data->name);
188        }
189
190        /* insert basic data into poi table */
191        status = sqlite3_reset(ppStmt);
192        if (status != SQLITE_OK )
193        {
194                g_print ("\n\nSQLite reset error\n");
195                exit (EXIT_FAILURE);
196        }
197        status = sqlite3_bind_text(ppStmt, 1, data->name, -1, SQLITE_TRANSIENT);
198        if (status != SQLITE_OK )
199        {
200                g_print ("\n\nSQLite bind error\n");
201                exit (EXIT_FAILURE);
202        }
203        status = sqlite3_bind_double(ppStmt, 2, (double)data->lat);
204        if (status != SQLITE_OK )
205        {
206                g_print ("\n\nSQLite bind error\n");
207                exit (EXIT_FAILURE);
208        }
209        status = sqlite3_bind_double(ppStmt, 3, (double)data->lon);
210        if (status != SQLITE_OK )
211        {
212                g_print ("\n\nSQLite bind error\n");
213                exit (EXIT_FAILURE);
214        }
215        status = sqlite3_bind_text(ppStmt, 4, data->poi_type, -1, SQLITE_TRANSIENT);
216        if (status != SQLITE_OK )
217        {
218                g_print ("\n\nSQLite bind error\n");
219                exit (EXIT_FAILURE);
220        }
221        status = sqlite3_step(ppStmt);
222        if (status != SQLITE_DONE )
223        {
224                g_print ("\n\nSQLite error: %s\n", sqlite3_errmsg(osm_db));
225                exit (EXIT_FAILURE);
226        }
227
228        /* insert additional tags into poi_extra table */
229        if (data->tag_count)
230        {
231                t_id = sqlite3_last_insert_rowid(osm_db);
232                if (t_id)
233                {
234                        for (i = 0; i < data->tag_count; i++)
235                        {
236                                if (verbose)
237                                {
238                                        g_print ("    |  %s = '%s'\n",
239                                        data->key[i], data->value[i]);
240                                }
241                                t_buf3 = escape_sql_string (data->key[i]);
242                                t_buf4 = escape_sql_string (data->value[i]);
243                                g_snprintf (query, sizeof (query),
244                                        "INSERT INTO poi_extra (poi_id, field_name, entry)"
245                                        " VALUES ('%ld','%s','%s')", t_id, t_buf3, t_buf4);
246                                status = sqlite3_exec(osm_db, query, NULL, NULL, &error_string);
247                                g_free (t_buf3);
248                                g_free (t_buf4);
249                                if (status != SQLITE_OK )
250                                {
251                                        g_print ("\n\nSQLite error: %s\n%s\n\n", error_string, query);
252                                        sqlite3_free(error_string);
253                                        exit (EXIT_FAILURE);
254                                }
255                        }
256                }
257        }
258}
259
260
261/* *****************************************************************************
262 * callback for parsing node xml data
263 */
264void
265parse_node_cb (node_struct *node)
266{
267        xmlChar *t_bid, *t_bla, *t_blo;
268
269        node->tag_count = 0;
270        t_bid = xmlTextReaderGetAttribute (xml_reader, BAD_CAST "id");
271        t_bla = xmlTextReaderGetAttribute (xml_reader, BAD_CAST "lat");
272        t_blo = xmlTextReaderGetAttribute (xml_reader, BAD_CAST "lon");
273        node->id = strtol ((gpointer) t_bid, NULL, 10);
274        node->lat = g_strtod ((gpointer) t_bla, NULL);
275        node->lon = g_strtod ((gpointer) t_blo, NULL);
276        xmlFree (t_bid);
277        xmlFree (t_bla);
278        xmlFree (t_blo);
279
280        g_strlcpy (node->name, "", sizeof (node->name));
281}
282
283/* *****************************************************************************
284 * callback for parsing tag xml data
285 */
286void
287parse_tag_cb (node_struct *node, gboolean *found_poi)
288{
289        gchar buf[255];
290        gchar *pt_pointer;
291
292        xmlChar *t_key, *t_val;
293
294        if (node->tag_count >= MAX_TAGS_PER_NODE)
295                return;
296
297        /* check if type of point is known, and set poi_type */
298        t_key = xmlTextReaderGetAttribute (xml_reader, BAD_CAST "k");
299        t_val = xmlTextReaderGetAttribute (xml_reader, BAD_CAST "v");
300        g_strlcpy (node->key[node->tag_count], (const gchar *)t_key,
301                sizeof node->key[node->tag_count]);
302        g_strlcpy (node->value[node->tag_count], (const gchar *)t_val,
303                sizeof (node->value[node->tag_count]));
304        xmlFree (t_key);
305        xmlFree (t_val);
306
307        /* skip 'created_by' tag */
308        if (strcmp ("created_by", node->key[node->tag_count]) == 0) {
309                return;
310        } else if (strcmp ("poi", node->key[node->tag_count]) == 0) {
311                /* override poi_type if 'poi' tag is available */
312                g_strlcpy (node->poi_type, node->value[node->tag_count],
313                        sizeof (node->poi_type));
314                return;
315        } else if (strcmp ("name", node->key[node->tag_count]) == 0) {
316                /* get name of node */
317                g_strlcpy (node->name, node->value[node->tag_count],
318                        sizeof (node->name));
319                return;
320        }
321
322        g_snprintf (buf, sizeof (buf), "%s=%s",
323                node->key[node->tag_count],
324                node->value[node->tag_count]);
325        pt_pointer = g_hash_table_lookup (poitypes_hash, buf);
326        if (pt_pointer)
327        {
328                poi_count++;
329                g_strlcpy (node->poi_type, pt_pointer, sizeof (node->poi_type));
330                *found_poi = TRUE;
331        }
332        else
333        {
334                node->tag_count++;
335        }
336}
337
338gint processXmlNode (void) {
339        gint xml_type;
340        gint depth;
341        const xmlChar *xml_name;
342        static gint child_node;
343        static node_struct node;
344        static gboolean found_poi;
345
346        xml_type = xmlTextReaderNodeType(xml_reader);
347        if (xml_type == XML_READER_TYPE_SIGNIFICANT_WHITESPACE)
348                return 1;
349
350        if (count % 10000 == 0)
351                g_print ("\r  poi: %ld / nodes: %ld / others: %ld", poi_count, node_count, count - poi_count - node_count);
352
353        depth = xmlTextReaderDepth (xml_reader);
354        if (depth < 1)
355                return 1;
356
357        if (depth == 1) {
358                count++;
359                if (xml_type == XML_READER_TYPE_ELEMENT) {
360                        if (xmlTextReaderIsEmptyElement(xml_reader))
361                                return 1;
362                        xml_name = xmlTextReaderConstName(xml_reader);
363                        if (xmlStrEqual(xml_name, BAD_CAST "node")) {
364                                child_node = 1;
365                                node_count++;
366                                parse_node_cb (&node);
367                                found_poi = FALSE;
368                        } else {
369                                child_node = 0;
370                                /* Usually the *.osm dump files are sorted in the
371                                 * order node/way/relation. So we can assume, that
372                                 * there will appear no more nodes after a 'way' or
373                                 * 'relation' element is found, and stop reading to
374                                 * speed up the processing */
375                                if (!nodes_done) {
376                                        if (xmlStrEqual(xml_name, BAD_CAST "way")
377                                            || xmlStrEqual(xml_name, BAD_CAST "relation"))
378                                        {
379                                                nodes_done = TRUE;
380                                                if (stop_on_way) {
381                                                        g_print ("\r  Reached end of nodes, terminating...\n");
382                                                        return 0;
383                                                } else {
384                                                        g_print ("\n\n\nFOUND WAY OR RELATION TAG!\n"
385                                                                "END OF NODES SECTION REACHED???\n\n\n");
386                                                }
387                                        }
388                                }
389                        }
390                } else if (xml_type == XML_READER_TYPE_END_ELEMENT
391                        && child_node == 1) {
392                        child_node = 0;
393                        if (found_poi)
394                                add_new_poi (&node);
395                }
396        } else if (depth == 2 && child_node) {
397                xml_name = xmlTextReaderConstName(xml_reader);
398                if (xml_type == XML_READER_TYPE_ELEMENT
399                    && xmlStrEqual (xml_name, BAD_CAST "tag"))
400                        parse_tag_cb (&node, &found_poi);
401        }
402
403        return 1;
404}
405
406
407/* *****************************************************************************
408 * on a INT signal, do a clean shutdown
409 */
410void signalhandler_int (int sig)
411{
412        if (parsing_active)
413        {
414                g_print ("\nCatched SIGINT - stopping parser !\n\n");
415                parsing_active = FALSE;
416                return;
417        }
418        else
419        {
420                g_print ("\nCatched SIGINT - shutting down !\n\n");
421                xmlFreeTextReader (xml_reader);
422                sqlite3_close (osm_db);
423                exit (EXIT_SUCCESS);
424        }
425}
426
427
428/*******************************************************************************
429 *                                                                             *
430 *                             Main program                                    *
431 *                                                                             *
432 *******************************************************************************/
433int
434main (int argc, char *argv[])
435{
436        gchar const rcsid[] = "$Id$";
437
438        GOptionContext *opt_context;
439        gchar *db_file = NULL;
440        gchar *osm_file = NULL;
441        GError *error = NULL;
442        GTimer *timer;
443        gint parsing_time = 0;
444
445        setlocale(LC_NUMERIC,"C");
446
447        const gchar sql_create_poitable[] =
448                "CREATE TABLE IF NOT EXISTS poi (\n"
449                "poi_id        INTEGER      PRIMARY KEY,\n"
450                "name          VARCHAR(80)  NOT NULL default \'not specified\',\n"
451                "poi_type      VARCHAR(160) NOT NULL default \'unknown\',\n"
452                "lat           DOUBLE       NOT NULL default \'0\',\n"
453                "lon           DOUBLE       NOT NULL default \'0\',\n"
454                "alt           DOUBLE                default \'0\',\n"
455                "comment       VARCHAR(255)          default NULL,\n"
456                "last_modified DATETIME     NOT NULL default \'0000-00-00\',\n"
457                "source_id     INTEGER      NOT NULL default \'1\',\n"
458                "private       CHAR(1)               default NULL);";
459
460        const gchar sql_create_poiextratable[] =
461                "CREATE TABLE IF NOT EXISTS poi_extra (\n"
462                "poi_id         INTEGER       NOT NULL default \'0\',\n"
463                "field_name     VARCHAR(160)  NOT NULL default \'0\',\n"
464                "entry          VARCHAR(8192) default NULL);";
465
466
467        /* parse commandline options */
468        opt_context = g_option_context_new (
469                "source.osm or STDIN");
470        const gchar opt_summary[] =
471                "  This program looks for entries indicating \"Points of Interest\"\n"
472                "  inside a given OSM XML file, and adds the data to an sqlite database\n"
473                "  file used by gpsdrive to access those data.\n";
474        const gchar opt_desc[] = "Website:\n  http://www.gpsdrive.de\n";
475        GOptionEntry opt_entries[] =
476        {
477                {"db-file", 'f', 0, G_OPTION_ARG_FILENAME, &db_file,
478                        "set alternate file for geoinfo database", "<FILE>"},
479                {"osm-file", 'o', 0, G_OPTION_ARG_FILENAME, &osm_file,
480                        "set alternate file for created database", "<FILE>"},
481                {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
482                        "show some detailed output", NULL},
483                {"stop-on-way", 'w', 0, G_OPTION_ARG_NONE, &stop_on_way,
484                        "stop parsing when a way or relation is found", NULL},
485                {"version", 0, 0, G_OPTION_ARG_NONE, &show_version,
486                        "show version info", NULL},
487                {NULL}
488        };
489        g_option_context_set_summary (opt_context, opt_summary);
490        g_option_context_set_description (opt_context, opt_desc);
491        g_option_context_add_main_entries (opt_context, opt_entries, NULL);
492        if (!g_option_context_parse (opt_context, &argc, &argv, &error))
493        {
494                g_print ("Parsing of commandline options failed: %s\n", error->message);
495                exit (EXIT_FAILURE);
496        }
497        g_print ("\nosm2poidb\n");
498        if (show_version)
499        {
500                g_print (" (C) 2008 Guenther Meyer <d.s.e (at) sordidmusic.com>\n"
501                        "\n Version %s\n\n", rcsid);
502                exit (EXIT_SUCCESS);
503        }
504
505        /* setup signal handler to gracefully handle a CTRL-C command */
506        signal (SIGINT, signalhandler_int);
507
508
509        /* create connection to gpsdrive geoinfo database */
510        g_print ("  + Initializing Database access\n");
511        if (db_file == NULL)
512                db_file = g_strdup (DB_GEOINFO);
513        if (verbose)
514                g_print ("     Using geoinfo database file: %s\n", db_file);
515        status = sqlite3_open (db_file, &geoinfo_db);
516        if (status != SQLITE_OK)
517        {
518                g_print ("   Error while opening %s: %s\n",
519                        db_file, sqlite3_errmsg (geoinfo_db));
520                sqlite3_close (geoinfo_db);
521                g_free (db_file);
522                exit (EXIT_FAILURE);
523        }
524        g_free (db_file);
525
526
527        /* backup old osm database file and create new one*/
528        if (osm_file == NULL)
529                osm_file = g_strdup (DB_OSMFILE);
530        g_print (" + Creating OSM database file: %s\n", osm_file);
531        if (g_file_test (osm_file, G_FILE_TEST_IS_REGULAR))
532        {
533                gchar *t_fbuf;
534                t_fbuf = g_strconcat (osm_file, ".bak", NULL);
535                if (g_rename (osm_file, t_fbuf) != 0)
536                {
537                        g_print ("   ERROR: Can't create backup of existing OSM database file\n");
538                        exit (EXIT_FAILURE);
539                }
540                g_free (t_fbuf);
541        }
542        status = sqlite3_open (osm_file, &osm_db);
543        if (status != SQLITE_OK)
544        {
545                g_print ("   Error while opening %s: %s\n",
546                        osm_file, sqlite3_errmsg (osm_db));
547                sqlite3_close (geoinfo_db);
548                g_free (osm_file);
549                exit (EXIT_FAILURE);
550        }
551        g_free (osm_file);
552
553
554        /* create table 'poi' in osm database file */
555        status = sqlite3_exec(osm_db, sql_create_poitable, NULL, NULL, &error_string);
556        if (status != SQLITE_OK )
557        {
558                g_print ("SQLite error: %s\n", error_string);
559                sqlite3_free(error_string);
560        }
561
562        /* add a dummy entry to the 'poi' table, to enforce a specific range
563         * for poi_id values. this is done, to avoid confusion with identical
564         * ids when joining the tables in gpsdrive */
565        status = sqlite3_exec(osm_db, "INSERT INTO poi (poi_id, name)"
566                " VALUES ('99999999','___DUMMY___');", NULL, NULL, &error_string);
567        if (status != SQLITE_OK )
568        {
569                g_print ("\n\nSQLite error: %s\n\n", error_string);
570                sqlite3_free(error_string);
571                exit (EXIT_FAILURE);
572        }
573
574        /* create table 'poi_extra' in osm database file */
575        status = sqlite3_exec(osm_db, sql_create_poiextratable, NULL, NULL, &error_string);
576        if (status != SQLITE_OK )
577        {
578                g_print ("SQLite error: %s\n", error_string);
579                sqlite3_free(error_string);
580        }
581
582
583        /* read poi_types for matching osm types from gpsdrive geoinfo.db */
584        g_print (" + Reading POI types from GpsDrive geoinfo database\n");
585        poitypes_hash = g_hash_table_new (g_str_hash, g_str_equal);
586        status = sqlite3_exec (geoinfo_db, "SELECT osm_condition,poi_type FROM poi_type WHERE"
587                " (osm_condition !='' AND osm_cond_2nd='' AND osm_cond_3rd='');",
588                read_poi_types_cb, NULL, &error_string);
589        if (status != SQLITE_OK )
590        {
591                g_print ("   SQLite error: %s\n", error_string);
592                sqlite3_free(error_string);
593                exit (EXIT_FAILURE);
594        }
595        if (verbose)
596                g_print ("   %d known POI types found.\n", g_hash_table_size (poitypes_hash));
597
598        /* start timer to show duration of parsing process */
599                timer = g_timer_new ();
600
601        /* parse xml file and write data into database */
602        if (!argv[1])
603        {
604                g_print ("\n Please supply a valid Openstreetmap XML-File!\n");
605                exit (EXIT_FAILURE);
606        }
607        if (strcmp ("STDIN", argv[1]) == 0)
608                xml_reader = xmlReaderForFd (STDIN_FILENO, "", NULL, 0);
609        else
610                xml_reader = xmlNewTextReaderFilename (argv[1]);
611        if (xml_reader == NULL)
612        {
613                g_print ("\nERROR: Unable to open %s\n", argv[1]);
614                g_print ("Please specify a valid OpenStreetMap XML file!\n");
615                exit (EXIT_FAILURE);
616        }
617
618        /* Open a transaction Entity */
619        status = sqlite3_exec(osm_db, "begin", NULL, NULL, &error_string);
620        if (status != SQLITE_OK )
621        {
622                g_print ("SQLite error: %s\n", error_string);
623                sqlite3_free(error_string);
624        }
625
626        status = sqlite3_prepare_v2(osm_db,
627                "INSERT INTO poi (name,lat,lon,poi_type,source_id,last_modified)"
628                        " VALUES (?,?,?,?,'4',CURRENT_TIMESTAMP);",
629                -1, &ppStmt, NULL);
630        if (status != SQLITE_OK )
631        {
632                g_print ("SQLite error: %s\n", sqlite3_errmsg(osm_db));
633                exit (EXIT_FAILURE);
634        }
635
636        g_print (" + Parsing OSM data from %s\n", argv[1]);
637        parsing_active = TRUE;
638        while (1)
639        {
640                status = xmlTextReaderRead (xml_reader);
641                if (status != 1)
642                        break;
643                status = processXmlNode ();
644                if (status != 1)
645                        break;
646                if (parsing_active==FALSE)
647                {
648                        status = 0;
649                        break;
650                }
651        }
652        xmlFreeTextReader (xml_reader);
653        if (status != 0)
654                g_print ("  Failed to parse '%s'\n", argv[1]);
655
656        status = sqlite3_finalize(ppStmt);
657        if (status != SQLITE_OK )
658        {
659                g_print ("SQLite error: %s\n", error_string);
660                sqlite3_free(error_string);
661        }
662
663
664        parsing_active = FALSE;
665        parsing_time = g_timer_elapsed (timer, NULL);
666        if (parsing_time < 60)
667                g_print ("\r  %ld of %ld nodes identified as POI in %d seconds\n",
668                        poi_count, node_count, parsing_time);
669        else
670                g_print ("\r  %ld of %ld nodes identified as POI in %d:%2d minutes\n",
671                        poi_count, node_count, parsing_time/60, parsing_time%60);
672
673
674        /* Close transaction Entity */
675        status = sqlite3_exec(osm_db, "commit", NULL, NULL, &error_string);
676        if (status != SQLITE_OK )
677        {
678                g_print ("SQLite error: %s\n", error_string);
679                sqlite3_free(error_string);
680        }
681
682        /* remove dummmy row */
683        status = sqlite3_exec(osm_db, "DELETE FROM poi WHERE poi_id='99999999';",
684                NULL, NULL, &error_string);
685        if (status != SQLITE_OK )
686        {
687                g_print ("\n\nSQLite error: %s\n\n", error_string);
688                sqlite3_free(error_string);
689                exit (EXIT_FAILURE);
690        }
691
692
693        /* fine-grained matching of osm-data */
694        g_print ("+ Matching OSM-Tags to GpsDrive POI-Types\n");
695        status = sqlite3_exec (geoinfo_db, "SELECT poi_type,osm_cond_2nd FROM poi_type WHERE"
696                " (osm_condition !='' AND osm_cond_2nd!='' AND osm_cond_3rd='');",
697                match_types_osm_fine_cb, NULL, &error_string);
698        if (status != SQLITE_OK )
699        {
700                g_print ("  SQLite error: %s\n", error_string);
701                sqlite3_free(error_string);
702                exit (EXIT_FAILURE);
703        }
704        status = sqlite3_exec (geoinfo_db, "SELECT poi_type,osm_cond_3rd FROM poi_type WHERE"
705                " (osm_condition !='' AND osm_cond_2nd!='' AND osm_cond_3rd!='');",
706                match_types_osm_fine_cb, NULL, &error_string);
707        if (status != SQLITE_OK )
708        {
709                g_print ("  SQLite error: %s\n", error_string);
710                sqlite3_free(error_string);
711                exit (EXIT_FAILURE);
712        }
713        sqlite3_close (geoinfo_db);
714
715
716        /* create index on poi column */
717        g_print ("+ Creating new index\n");
718        status = sqlite3_exec(osm_db,
719                "CREATE INDEX poi_typelatlon ON poi (poi_type,lat,lon); "
720                "CREATE INDEX poi_latlon ON poi (lat,lon); "
721                "CREATE INDEX poi_name ON poi (name,comment); "
722                "CREATE INDEX poi_id ON poi_extra (poi_id); "
723                , NULL, NULL, &error_string);
724        if (status != SQLITE_OK )
725        {
726                g_print ("\n\nSQLite error: %s\n\n", error_string);
727                sqlite3_free(error_string);
728                exit (EXIT_FAILURE);
729        }
730
731
732        /* clean up connections */
733        g_print ("+ Closing Database access\n");
734        sqlite3_close (osm_db);
735
736        g_print ("\nFinished.\n");
737
738        return EXIT_SUCCESS;
739}
Note: See TracBrowser for help on using the repository browser.