main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 80 of file shp2pgsql-cli.c.

{
        SHPLOADERCONFIG *config;
        SHPLOADERSTATE *state;
        char *header, *footer, *record;
        int c;
        int ret, i;
 
#ifdef ENABLE_NLS
#ifdef PGSQL_LOCALEDIR
        setlocale (LC_ALL, "");
        bindtextdomain (PACKAGE, PGSQL_LOCALEDIR);
        textdomain (PACKAGE);
#endif
#endif
 
        /* If no options are specified, display usage */
        if (argc == 1)
        {
                usage();
                exit(0);
        }
 
        /* Parse command line options and set configuration */
        config = malloc(sizeof(SHPLOADERCONFIG));
        set_loader_config_defaults(config);
 
        /* Keep the flag list alphabetic so it's easy to see what's left. */
        while ((c = pgis_getopt(argc, argv, "-?acdeg:ikm:nps:t:wDGIN:ST:W:X:Z")) != EOF)
        {
                // can not do this inside the switch case
                if ('-' == c)
                        break;
 
                switch (c)
                {
                case 'c':
                case 'd':
                case 'a':
                case 'p':
                        config->opt = c;
                        break;
 
                case 'D':
                        config->dump_format = 1;
                        break;
 
                case 'G':
                        config->geography = 1;
                        break;
 
                case 'Z':
                        config->analyze = 0;
                        break;
 
                case 'S':
                        config->simple_geometries = 1;
                        break;
 
                case 's':
                        if (pgis_optarg)
                        {
                                char *ptr = strchr(pgis_optarg, ':');
                                if (ptr)
                                {
                                        *ptr++ = '\0';
                                        sscanf(pgis_optarg, "%d", &config->shp_sr_id);
                                        sscanf(ptr, "%d", &config->sr_id);
                                }
                                else
                                {
                                        /* Only TO_SRID specified */
                                        sscanf(pgis_optarg, "%d", &config->sr_id);
                                }
                        }
                        else
                        {
                                /* With -s, user must specify TO_SRID or FROM_SRID:TO_SRID */
                                fprintf(stderr, "The -s parameter must be specified in the form [FROM_SRID:]TO_SRID\n");
                                exit(1);
                        }
                        break;
                case 'g':
                        config->geo_col = pgis_optarg;
                        break;
                case 'm':
                        config->column_map_filename = pgis_optarg;
                        break;
 
                case 'k':
                        config->quoteidentifiers = 1;
                        break;
 
                case 'i':
                        config->forceint4 = 1;
                        break;
 
                case 'I':
                        config->createindex = 1;
                        break;
 
                case 'w':
                        config->use_wkt = 1;
                        break;
 
                case 'n':
                        config->readshape = 0;
                        break;
 
                case 'W':
                        free(config->encoding);
                        config->encoding = strdup(pgis_optarg);
                        break;
 
                case 'N':
                        switch (pgis_optarg[0])
                        {
                        case 'a':
                                config->null_policy = POLICY_NULL_ABORT;
                                break;
                        case 'i':
                                config->null_policy = POLICY_NULL_INSERT;
                                break;
                        case 's':
                                config->null_policy = POLICY_NULL_SKIP;
                                break;
                        default:
                                fprintf(stderr, "Unsupported NULL geometry handling policy.\nValid policies: insert, skip, abort\n");
                                exit(1);
                        }
                        break;
 
                case 't':
                        if (strcasecmp(pgis_optarg, "2D") == 0)
                        {
                                config->force_output = FORCE_OUTPUT_2D;
                        }
                        else if (strcasecmp(pgis_optarg, "3DZ") == 0 )
                        {
                                config->force_output = FORCE_OUTPUT_3DZ;
                        }
                        else if (strcasecmp(pgis_optarg, "3DM") == 0 )
                        {
                                config->force_output = FORCE_OUTPUT_3DM;
                        }
                        else if (strcasecmp(pgis_optarg, "4D") == 0 )
                        {
                                config->force_output = FORCE_OUTPUT_4D;
                        }
                        else
                        {
                                fprintf(stderr, "Unsupported output type: %s\nValid output types are 2D, 3DZ, 3DM and 4D\n", pgis_optarg);
                                exit(1);
                        }
                        break;
 
                case 'T':
                        config->tablespace = pgis_optarg;
                        break;
 
                case 'X':
                        config->idxtablespace = pgis_optarg;
                        break;
 
                case 'e':
                        config->usetransaction = 0;
                        break;
 
                case '?':
                        usage();
                        exit(0);
 
                default:
                        usage();
                        exit(0);
                }
        }
 
        /* Once we have parsed the arguments, make sure certain combinations are valid */
        if (config->dump_format && !config->usetransaction)
        {
                fprintf(stderr, "Invalid argument combination - cannot use both -D and -e\n");
                exit(1);
        }
 
        /* Determine the shapefile name from the next argument, if no shape file, exit. */
        if (pgis_optind < argc)
        {
                config->shp_file = argv[pgis_optind];
                pgis_optind++;
        }
        else
        {
                usage();
                exit(0);
        }
 
        /* Determine the table and schema names from the next argument */
        if (pgis_optind < argc)
        {
                char *strptr = argv[pgis_optind];
                char *chrptr = strchr(strptr, '.');
 
                /* OK, this is a schema-qualified table name... */
                if (chrptr)
                {
                        if ( chrptr == strptr )
                        {
                                /* ".something" ??? */
                                usage();
                                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);
                }
        }
 
        /* If the table parameter is not provided, use the shape file name as a proxy value.
           Strip out the .shp and the leading path information first. */
        if ( config->shp_file && config->table == NULL)
        {
                char *shp_file = strdup(config->shp_file);
                char *ptr;
 
                if ( shp_file == NULL )
                {
                        fprintf(stderr, "Unable to allocate memory for shapefile name\n");
                        exit(1);
                }
 
                /* Remove the extension, if present */
                for ( ptr = shp_file + strlen(shp_file); ptr > shp_file; ptr-- )
                {
                        if ( *ptr == '.' )
                        {
                                *ptr = '\0';
                                break;
                        }
                }
 
                /* The remaining non-path section is the table name */
                for ( ptr = shp_file + strlen(shp_file); ptr > shp_file; ptr-- )
                {
                        if ( *ptr == '/' || *ptr == '\\' )
                        {
                                ptr++;
                                break;
                        }
                }
                config->table = strdup(ptr);
                free(shp_file);
        }
 
 
        /* Transform table name to lower case if no quoting specified */
        if (!config->quoteidentifiers)
        {
                if ( config->table )
                        strtolower(config->table);
                if ( config->schema )
                        strtolower(config->schema);
        }
 
        /* Create the shapefile state object */
        state = ShpLoaderCreate(config);
 
        /* Open the shapefile */
        ret = ShpLoaderOpenShape(state);
        if (ret != SHPLOADEROK)
        {
                fprintf(stderr, "%s\n", state->message);
 
                if (ret == SHPLOADERERR)
                        exit(1);
        }
 
        /* If reading the whole shapefile, display its type */
        if (state->config->readshape)
        {
                fprintf(stderr, "Shapefile type: %s\n", SHPTypeName(state->shpfiletype));
                fprintf(stderr, "Postgis type: %s[%d]\n", state->pgtype, state->pgdims);
        }
 
        /* Print the header to stdout */
        ret = ShpLoaderGetSQLHeader(state, &header);
        if (ret != SHPLOADEROK)
        {
                fprintf(stderr, "%s\n", state->message);
 
                if (ret == SHPLOADERERR)
                        exit(1);
        }
 
        printf("%s", header);
        free(header);
 
        /* If we are not in "prepare" mode, go ahead and write out the data. */
        if ( state->config->opt != 'p' )
        {
 
                /* If in COPY mode, output the COPY statement */
                if (state->config->dump_format)
                {
                        ret = ShpLoaderGetSQLCopyStatement(state, &header);
                        if (ret != SHPLOADEROK)
                        {
                                fprintf(stderr, "%s\n", state->message);
 
                                if (ret == SHPLOADERERR)
                                        exit(1);
                        }
 
                        printf("%s", header);
                        free(header);
                }
 
                /* Main loop: iterate through all of the records and send them to stdout */
                for (i = 0; i < ShpLoaderGetRecordCount(state); i++)
                {
                        ret = ShpLoaderGenerateSQLRowStatement(state, i, &record);
 
                        switch (ret)
                        {
                        case SHPLOADEROK:
                                /* Simply display the geometry */
                                printf("%s\n", record);
                                free(record);
                                break;
 
                        case SHPLOADERERR:
                                /* Display the error message then stop */
                                fprintf(stderr, "%s\n", state->message);
                                exit(1);
                                break;
 
                        case SHPLOADERWARN:
                                /* Display the warning, but continue */
                                fprintf(stderr, "%s\n", state->message);
                                printf("%s\n", record);
                                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;
                        }
                }
 
                /* If in COPY mode, terminate the COPY statement */
                if (state->config->dump_format)
                        printf("\\.\n");
 
        }
 
        /* Print the footer to stdout */
        ret = ShpLoaderGetSQLFooter(state, &footer);
        if (ret != SHPLOADEROK)
        {
                fprintf(stderr, "%s\n", state->message);
 
                if (ret == SHPLOADERERR)
                        exit(1);
        }
 
        printf("%s", footer);
        free(footer);
 
 
        /* Free the state object */
        ShpLoaderDestroy(state);
 
        /* Free configuration variables */
        free(config->schema);
        free(config->table);
        free(config->encoding);
        free(config);
 
        return 0;
}

References shp_loader_config::analyze, shp_loader_config::column_map_filename, shp_loader_state::config, shp_loader_config::createindex, shp_loader_config::dump_format, shp_loader_config::encoding, shp_loader_config::force_output, FORCE_OUTPUT_2D, FORCE_OUTPUT_3DM, FORCE_OUTPUT_3DZ, FORCE_OUTPUT_4D, shp_loader_config::forceint4, free(), shp_loader_config::geo_col, shp_loader_config::geography, shp_loader_config::idxtablespace, malloc(), shp_loader_state::message, shp_loader_config::null_policy, shp_loader_config::opt, shp_loader_state::pgdims, pgis_getopt(), pgis_optarg, pgis_optind, shp_loader_state::pgtype, POLICY_NULL_ABORT, POLICY_NULL_INSERT, POLICY_NULL_SKIP, shp_loader_config::quoteidentifiers, shp_loader_config::readshape, shp_loader_config::schema, set_loader_config_defaults(), shp_loader_config::shp_file, shp_loader_config::shp_sr_id, 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, strtolower(), shp_loader_config::table, shp_loader_config::tablespace, usage(), shp_loader_config::use_wkt, and shp_loader_config::usetransaction.

Here is the call graph for this function: