pgui_action_import()

static void pgui_action_import ( GtkWidget *  widget, gpointer  data  )

static

Definition at line 1415 of file shp2pgsql-gui.c.

References _, shp_loader_state::config, connection_test(), shp_loader_config::createindex, dialog_progress, shp_loader_config::dump_format, FALSE, free(), shp_loader_config::geo_col, shp_loader_config::geography, GUIMSG_LINE_MAXLEN, import_file_list_store, IMPORT_POINTER_COLUMN, is_running, label_progress, malloc(), shp_loader_state::message, shp_loader_config::opt, pg_connection, shp_loader_state::pgdims, shp_loader_state::pgtype, pgui_copy_end(), pgui_copy_start(), pgui_copy_write(), pgui_exec(), pgui_logf(), pgui_raise_error_dialogue(), pgui_seterr(), progress, shp_loader_config::readshape, shp_loader_config::schema, shp_loader_config::shp_file, ShpDumperGetConnectionStringFromConn(), shp_loader_state::shpfiletype, ShpLoaderCreate(), ShpLoaderDestroy(), SHPLOADERERR, ShpLoaderGenerateSQLRowStatement(), ShpLoaderGetRecordCount(), ShpLoaderGetSQLCopyStatement(), ShpLoaderGetSQLFooter(), ShpLoaderGetSQLHeader(), SHPLOADEROK, ShpLoaderOpenShape(), SHPLOADERRECDELETED, SHPLOADERRECISNULL, SHPLOADERWARN, SHPTypeName(), shp_loader_config::simple_geometries, shp_loader_config::sr_id, shp_loader_config::table, TRUE, update_conn_ui_from_conn_config(), validate_remote_loader_columns(), and window_conn.

Referenced by pgui_create_main_window().

{
        SHPLOADERCONFIG *loader_file_config;
        SHPLOADERSTATE *state;
        gint is_valid;
        gpointer gptr;
        GtkTreeIter iter;
        char *sql_form, *query, *connection_string, *progress_shapefile = NULL;
  char progress_text[GUIMSG_LINE_MAXLEN+1];
        PGresult *result;

        int ret, i = 0;
        char *header, *footer, *record;

        /* Get the first row of the import list */
        is_valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(import_file_list_store), &iter);
        if (!is_valid)
        {
                pgui_seterr(_("ERROR: You haven't specified any files to import"));
                pgui_raise_error_dialogue();

                return;
        }

        /* Firstly make sure that we can connect to the database - if we can't then there isn't much
           point doing anything else... */
        if (!connection_test())
        {
                pgui_seterr(_("Unable to connect to the database - please check your connection settings"));
                pgui_raise_error_dialogue();

                /* Open the connections UI for the user */
                update_conn_ui_from_conn_config();

                gtk_widget_show_all(GTK_WIDGET(window_conn));
                return;
        }

        /* Let's open a single connection to the remote DB for the duration of the validation pass;
           note that we already know the connection string works, otherwise we would have bailed
           out earlier in the function */
        connection_string = ShpDumperGetConnectionStringFromConn(conn);
        pg_connection = PQconnectdb(connection_string);

        /* Setup the table/column type discovery query */
        sql_form = "SELECT a.attnum, a.attname AS field, t.typname AS type, a.attlen AS length, a.atttypmod AS precision FROM pg_class c, pg_attribute a, pg_type t, pg_namespace n WHERE c.relname = '%s' AND n.nspname = '%s' AND a.attnum > 0 AND a.attrelid = c.oid AND a.atttypid = t.oid AND c.relnamespace = n.oid ORDER BY a.attnum";

        /* Validation: we loop through each of the files in order to validate them as a separate pass */
        while (is_valid)
        {
                /* Grab the SHPLOADERCONFIG for this row */
                gtk_tree_model_get(GTK_TREE_MODEL(import_file_list_store), &iter, IMPORT_POINTER_COLUMN, &gptr, -1);
                loader_file_config = (SHPLOADERCONFIG *)gptr;

                /* For each entry, we execute a remote query in order to determine the column names
                   and types for the remote table if they actually exist */
                query = malloc(strlen(sql_form) + strlen(loader_file_config->schema) + strlen(loader_file_config->table) + 1);
                sprintf(query, sql_form, loader_file_config->table, loader_file_config->schema);
                result = PQexec(pg_connection, query);

                /* Call the validation function with the SHPLOADERCONFIG and the result set */
                ret = validate_remote_loader_columns(loader_file_config, result);
                if (ret == SHPLOADERERR)
                {
                        pgui_raise_error_dialogue();

                        PQclear(result);
                        free(query);

                        return;
                }

                /* Free the SQL query */
                PQclear(result);
                free(query);

                /* Get next entry */
                is_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(import_file_list_store), &iter);
        }

        /* Close our database connection */
        PQfinish(pg_connection);


        /* Once we've done the validation pass, now let's load the shapefile */
        is_valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(import_file_list_store), &iter);
        while (is_valid)
        {
                /* Grab the SHPLOADERCONFIG for this row */
                gtk_tree_model_get(GTK_TREE_MODEL(import_file_list_store), &iter, IMPORT_POINTER_COLUMN, &gptr, -1);
                loader_file_config = (SHPLOADERCONFIG *)gptr;

                pgui_logf("\n==============================");
                pgui_logf("Importing with configuration: %s, %s, %s, %s, mode=%c, dump=%d, simple=%d, geography=%d, index=%d, shape=%d, srid=%d", loader_file_config->table, loader_file_config->schema, loader_file_config->geo_col, loader_file_config->shp_file, loader_file_config->opt, loader_file_config->dump_format, loader_file_config->simple_geometries, loader_file_config->geography, loader_file_config->createindex, loader_file_config->readshape, loader_file_config->sr_id);

                /*
                 * Loop through the items in the shapefile
                 */
                is_running = TRUE;

                /* One connection per file, otherwise error handling becomes tricky... */
                pg_connection = PQconnectdb(connection_string);

                /* Disable the button to prevent multiple imports running at the same time */
                gtk_widget_set_sensitive(widget, FALSE);

                /* Allow GTK events to get a look in */
                while (gtk_events_pending())
                        gtk_main_iteration();

                /* Create the shapefile state object */
                state = ShpLoaderCreate(loader_file_config);

                /* Open the shapefile */
                ret = ShpLoaderOpenShape(state);
                if (ret != SHPLOADEROK)
                {
                        pgui_logf("%s", state->message);

                        if (ret == SHPLOADERERR)
                                goto import_cleanup;
                }

                /* For progress display, only show the "core" filename */
                for (i = strlen(loader_file_config->shp_file); i >= 0
                        && loader_file_config->shp_file[i - 1] != '\\' && loader_file_config->shp_file[i - 1] != '/'; i--);

                progress_shapefile = malloc(strlen(loader_file_config->shp_file));
                strcpy(progress_shapefile, &loader_file_config->shp_file[i]);

                /* Display the progress dialog */
                snprintf(progress_text, GUIMSG_LINE_MAXLEN, _("Importing shapefile %s (%d records)..."), progress_shapefile, ShpLoaderGetRecordCount(state));
                progress_text[GUIMSG_LINE_MAXLEN] = '\0';
                gtk_label_set_text(GTK_LABEL(label_progress), progress_text);
                gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), 0.0);
                gtk_widget_show_all(dialog_progress);

                /* If reading the whole shapefile, display its type */
                if (state->config->readshape)
                {
                        pgui_logf("Shapefile type: %s", SHPTypeName(state->shpfiletype));
                        pgui_logf("PostGIS type: %s[%d]", state->pgtype, state->pgdims);
                }

                /* Get the header */
                ret = ShpLoaderGetSQLHeader(state, &header);
                if (ret != SHPLOADEROK)
                {
                        pgui_logf("%s", state->message);

                        if (ret == SHPLOADERERR)
                                goto import_cleanup;
                }

                /* Send the header to the remote server: if we are in COPY mode then the last
                   statement will be a COPY and so will change connection mode */
                ret = pgui_exec(header);
                free(header);

                if (!ret)
                        goto import_cleanup;

                /* If we are in prepare mode, we need to skip the actual load. */
                if (state->config->opt != 'p')
                {
            int numrecords = ShpLoaderGetRecordCount(state);
            int records_per_tick = (numrecords / 200) - 1;

            if ( records_per_tick < 1 )
                records_per_tick = 1;

                        /* If we are in COPY (dump format) mode, output the COPY statement and enter COPY mode */
                        if (state->config->dump_format)
                        {
                                ret = ShpLoaderGetSQLCopyStatement(state, &header);

                                if (ret != SHPLOADEROK)
                                {
                                        pgui_logf("%s", state->message);

                                        if (ret == SHPLOADERERR)
                                                goto import_cleanup;
                                }

                                /* Send the result to the remote server: this should put us in COPY mode */
                                ret = pgui_copy_start(header);
                                free(header);

                                if (!ret)
                                        goto import_cleanup;
                        }

                        /* Main loop: iterate through all of the records and send them to stdout */
                        for (i = 0; i < numrecords && is_running; i++)
                        {
                                ret = ShpLoaderGenerateSQLRowStatement(state, i, &record);

                                switch (ret)
                                {
                                case SHPLOADEROK:
                                        /* Simply send the statement */
                                        if (state->config->dump_format)
                                                ret = pgui_copy_write(record);
                                        else
                                                ret = pgui_exec(record);

                                        /* Display a record number if we failed */
                                        if (!ret)
                                                pgui_logf(_("Import failed on record number %d"), i);

                                        free(record);
                                        break;

                                case SHPLOADERERR:
                                        /* Display the error message then stop */
                                        pgui_logf("%s\n", state->message);
                                        goto import_cleanup;
                                        break;

                                case SHPLOADERWARN:
                                        /* Display the warning, but continue */
                                        pgui_logf("%s\n", state->message);

                                        if (state->config->dump_format)
                                                ret = pgui_copy_write(record);
                                        else
                                                ret = pgui_exec(record);

                                        /* Display a record number if we failed */
                                        if (!ret)
                                                pgui_logf(_("Import failed on record number %d"), i);

                                        free(record);
                                        break;

                                case SHPLOADERRECDELETED:
                                        /* Record is marked as deleted - ignore */
                                        break;

                                case SHPLOADERRECISNULL:
                                        /* Record is NULL and should be ignored according to NULL policy */
                                        break;
                                }

                                /* Update the progress bar */
                                if ( i % records_per_tick == 0 )
                                    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), (float)i / numrecords);

                                /* Allow GTK events to get a look in */
                                while (gtk_events_pending())
                                        gtk_main_iteration();
                        }

                        /* If we are in COPY (dump format) mode, leave COPY mode */
                        if (state->config->dump_format)
                        {
                                if (! pgui_copy_end(0) )
                                        goto import_cleanup;

                                result = PQgetResult(pg_connection);
                                if (PQresultStatus(result) != PGRES_COMMAND_OK)
                                {
                                        pgui_logf(_("COPY failed with the following error: %s"), PQerrorMessage(pg_connection));
                                        ret = SHPLOADERERR;
                                        goto import_cleanup;
                                }
                        }
                } /* if (state->config->opt != 'p') */

                /* Only continue if we didn't abort part way through */
                if (is_running)
                {
                        /* Get the footer */
                        ret = ShpLoaderGetSQLFooter(state, &footer);
                        if (ret != SHPLOADEROK)
                        {
                                pgui_logf("%s\n", state->message);

                                if (ret == SHPLOADERERR)
                                        goto import_cleanup;
                        }

                        /* Just in case index creation takes a long time, update the progress text */
                        if (state->config->createindex)
                        {
                                gtk_label_set_text(GTK_LABEL(label_progress), _("Creating spatial index..."));

                                /* Allow GTK events to get a look in */
                                while (gtk_events_pending())
                                        gtk_main_iteration();
                        }

                        /* Send the footer to the server */
                        ret = pgui_exec(footer);
                        free(footer);

                        if (!ret)
                                goto import_cleanup;
                }

import_cleanup:
                /* Import has definitely stopped running */
                is_running = FALSE;

                /* Close the existing connection */
                PQfinish(pg_connection);
                pg_connection = NULL;

                /* If we didn't finish inserting all of the items (and we expected to), an error occurred */
                if ((state->config->opt != 'p' && i != ShpLoaderGetRecordCount(state)) || !ret)
                        pgui_logf(_("Shapefile import failed."));
                else
                        pgui_logf(_("Shapefile import completed."));

                /* Free the state object */
                ShpLoaderDestroy(state);

                /* Tidy up */
                if (progress_shapefile)
                        free(progress_shapefile);

                /* Get next entry */
                is_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(import_file_list_store), &iter);
        }

        /* Import has definitely finished */
        is_running = FALSE;

        /* Enable the button once again */
        gtk_widget_set_sensitive(widget, TRUE);

        /* Silly GTK bug means we have to hide and show the button for it to work again! */
        gtk_widget_hide(widget);
        gtk_widget_show(widget);

        /* Hide the progress dialog */
        gtk_widget_hide(dialog_progress);

        /* Allow GTK events to get a look in */
        while (gtk_events_pending())
                gtk_main_iteration();

        /* Tidy up */
        free(connection_string);

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function: