main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 59 of file pgsql2shp-cli.c.

{
        SHPDUMPERCONFIG *config;
        SHPDUMPERSTATE *state;
 
        int ret, c, i;
 
        /* If no options are specified, display usage */
        if (argc == 1)
        {
                usage(0); /* TODO: should this exit with error ? */
        }
 
        /* Parse command line options and set configuration */
        config = malloc(sizeof(SHPDUMPERCONFIG));
        set_dumper_config_defaults(config);
 
        while ((c = pgis_getopt(argc, argv, "bf:h:du:p:P:g:rkm:q")) != EOF)
        {
                switch (c)
                {
                case 'b':
                        config->binary = 1;
                        break;
                case 'f':
                        config->shp_file = pgis_optarg;
                        break;
                case 'h':
                        config->conn->host = pgis_optarg;
                        break;
                case 'd':
                        config->dswitchprovided = 1;
                        break;
                case 'r':
                        config->includegid = 1;
                        config->unescapedattrs = 1;
                        break;
                case 'u':
                        config->conn->username = pgis_optarg;
                        break;
                case 'p':
                        config->conn->port = pgis_optarg;
                        break;
                case 'P':
                        config->conn->password = pgis_optarg;
                        break;
                case 'g':
                        config->geo_col_name = pgis_optarg;
                        break;
                case 'm':
                        config->column_map_filename = pgis_optarg;
                        break;
                case 'k':
                        config->keep_fieldname_case = 1;
                        break;
                case 'q':
                        config->quiet = 1;
                        break;
                default:
                        usage(pgis_optopt == '?' ? 0 : 1);
                }
        }
 
 
        /* Determine the database name from the next argument, if no database, exit. */
        if (pgis_optind < argc)
        {
                config->conn->database = argv[pgis_optind];
                pgis_optind++;
        }
        else
        {
                usage(1);
        }
 
 
        /* Determine the table and schema names from the next argument if supplied, otherwise if
           it's a user-defined query then set that instead */
        if (pgis_optind < argc)
        {
                /* User-defined queries begin with SELECT or WITH */
                if ( !strncmp(argv[pgis_optind], "SELECT ", 7) ||
                        !strncmp(argv[pgis_optind], "select ", 7) ||
                        !strncmp(argv[pgis_optind], "WITH ", 5) ||
                        !strncmp(argv[pgis_optind], "with ", 5)
                )
                {
                        config->usrquery = argv[pgis_optind];
                }
                else
                {
                        /* Schema qualified table name */
                        char *strptr = argv[pgis_optind];
                        char *chrptr = strchr(strptr, '.');
 
                        /* OK, this is a schema-qualified table name... */
                        if (chrptr)
                        {
                                if ( chrptr == strptr )
                                {
                                        /* table is ".something" display help  */
                                        usage(0);
                                        exit(0);
                                }
                                /* Null terminate at the '.' */
                                *chrptr = '\0';
                                /* Copy in the parts */
                                config->schema = strdup(strptr);
                                config->table = strdup(chrptr+1);
                        }
                        else
                        {
                                config->table = strdup(strptr);
                        }
                }
        }
        else
        {
                usage(1);
        }
 
        state = ShpDumperCreate(config);
 
        ret = ShpDumperConnectDatabase(state);
        if (ret != SHPDUMPEROK)
        {
                fprintf(stderr, "%s\n", state->message);
                fflush(stderr);
                exit(1);
        }
 
        /* Display a warning if the -d switch is used with PostGIS >= 1.0 */
        if (state->pgis_major_version > 0 && state->config->dswitchprovided)
        {
                fprintf(stderr, _("WARNING: -d switch is useless when dumping from postgis-1.0.0+\n"));
                fflush(stderr);
        }
 
        /* Open the table ready to return rows */
        if (!state->config->quiet)
        {
                fprintf(stdout, _("Initializing... \n"));
                fflush(stdout);
        }
 
        ret = ShpDumperOpenTable(state);
        if (ret != SHPDUMPEROK)
        {
                fprintf(stderr, "%s\n", state->message);
                fflush(stderr);
 
                if (ret == SHPDUMPERERR)
                        exit(1);
        }
 
        if (!state->config->quiet)
        {
                fprintf(stdout, _("Done (postgis major version: %d).\n"), state->pgis_major_version);
                fprintf(stdout, _("Output shape: %s\n"), shapetypename(state->outshptype));
                fprintf(stdout, _("Dumping: "));
                fflush(stdout);
        }
 
        for (i = 0; i < ShpDumperGetRecordCount(state); i++)
        {
                /* Mimic existing behaviour */
                if (!state->config->quiet && !(state->currow % state->config->fetchsize))
                {
                        fprintf(stdout, "X");
                        fflush(stdout);
                }
 
                ret = ShpLoaderGenerateShapeRow(state);
                if (ret != SHPDUMPEROK)
                {
                        fprintf(stderr, "%s\n", state->message);
                        fflush(stderr);
 
                        if (ret == SHPDUMPERERR)
                                exit(1);
                }
        }
 
        if (!state->config->quiet)
        {
                fprintf(stdout, _(" [%d rows].\n"), ShpDumperGetRecordCount(state));
                fflush(stdout);
        }
 
        ret = ShpDumperCloseTable(state);
        if (ret != SHPDUMPEROK)
        {
                fprintf(stderr, "%s\n", state->message);
                fflush(stderr);
 
                if (ret == SHPDUMPERERR)
                        ret = 1;
                else
                        ret = 0;
        }
        else
                ret = 0;
 
        ShpDumperDestroy(state);
 
        free(config->conn);
        free(config->table);
        free(config->schema);
        free(config);
 
        return ret;
}

References _, shp_dumper_config::binary, shp_dumper_config::column_map_filename, shp_dumper_state::config, shp_dumper_config::conn, shp_dumper_state::currow, shp_connection_state::database, shp_dumper_config::dswitchprovided, shp_dumper_config::fetchsize, free(), shp_dumper_config::geo_col_name, shp_connection_state::host, shp_dumper_config::includegid, shp_dumper_config::keep_fieldname_case, malloc(), shp_dumper_state::message, shp_dumper_state::outshptype, shp_connection_state::password, pgis_getopt(), shp_dumper_state::pgis_major_version, pgis_optarg, pgis_optind, pgis_optopt, shp_connection_state::port, shp_dumper_config::quiet, shp_dumper_config::schema, set_dumper_config_defaults(), shapetypename(), shp_dumper_config::shp_file, ShpDumperCloseTable(), ShpDumperConnectDatabase(), ShpDumperCreate(), ShpDumperDestroy(), SHPDUMPERERR, ShpDumperGetRecordCount(), SHPDUMPEROK, ShpDumperOpenTable(), ShpLoaderGenerateShapeRow(), shp_dumper_config::table, shp_dumper_config::unescapedattrs, usage(), shp_connection_state::username, and shp_dumper_config::usrquery.

Here is the call graph for this function: