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

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