ShpLoaderOpenShape()

int ShpLoaderOpenShape

(

SHPLOADERSTATE *

state

)

Definition at line 846 of file shp2pgsql-core.c.

{
        SHPObject *obj = NULL;
        int ret = SHPLOADEROK;
        char name[MAXFIELDNAMELEN];
        DBFFieldType type = FTInvalid;
        char *utf8str;
 
        /* If we are reading the entire shapefile, open it */
        if (state->config->readshape == 1)
        {
                state->hSHPHandle = SHPOpen(state->config->shp_file, "rb");
 
                if (state->hSHPHandle == NULL)
                {
                        snprintf(state->message, SHPLOADERMSGLEN, _("%s: shape (.shp) or index files (.shx) can not be opened, will just import attribute data."), state->config->shp_file);
                        state->config->readshape = 0;
 
                        ret = SHPLOADERWARN;
                }
        }
 
        /* Open the DBF (attributes) file */
        state->hDBFHandle = DBFOpen(state->config->shp_file, "rb");
        if ((state->hSHPHandle == NULL && state->config->readshape == 1) || state->hDBFHandle == NULL)
        {
                snprintf(state->message, SHPLOADERMSGLEN, _("%s: dbf file (.dbf) can not be opened."), state->config->shp_file);
 
                return SHPLOADERERR;
        }
 
 
        /* Open the column map if one was specified */
        if (state->config->column_map_filename)
        {
                ret = colmap_read(state->config->column_map_filename,
                                  &state->column_map, state->message, SHPLOADERMSGLEN);
                if (!ret) return SHPLOADERERR;
        }
 
        /* User hasn't altered the default encoding preference... */
        if ( strcmp(state->config->encoding, ENCODING_DEFAULT) == 0 )
        {
            /* But the file has a code page entry... */
            if ( state->hDBFHandle->pszCodePage )
            {
                /* And we figured out what iconv encoding it maps to, so use it! */
            char *newencoding = NULL;
                if ( (newencoding = codepage2encoding(state->hDBFHandle->pszCodePage)) )
                {
                lwfree(state->config->encoding);
                state->config->encoding = newencoding;
            }
        }
        }
 
        /* If reading the whole shapefile (not just attributes)... */
        if (state->config->readshape == 1)
        {
                SHPGetInfo(state->hSHPHandle, &state->num_entities, &state->shpfiletype, NULL, NULL);
 
                /* If null_policy is set to abort, check for NULLs */
                if (state->config->null_policy == POLICY_NULL_ABORT)
                {
                        /* If we abort on null items, scan the entire file for NULLs */
                        for (int j = 0; j < state->num_entities; j++)
                        {
                                obj = SHPReadObject(state->hSHPHandle, j);
 
                                if (!obj)
                                {
                                        snprintf(state->message, SHPLOADERMSGLEN, _("Error reading shape object %d"), j);
                                        return SHPLOADERERR;
                                }
 
                                if (obj->nVertices == 0)
                                {
                                        snprintf(state->message, SHPLOADERMSGLEN, _("Empty geometries found, aborted.)"));
                                        return SHPLOADERERR;
                                }
 
                                SHPDestroyObject(obj);
                        }
                }
 
                /* Check the shapefile type */
                int geomtype = 0;
                switch (state->shpfiletype)
                {
                case SHPT_POINT:
                        /* Point */
                        state->pgtype = "POINT";
                        geomtype = POINTTYPE;
                        state->pgdims = 2;
                        break;
 
                case SHPT_ARC:
                        /* PolyLine */
                        state->pgtype = "MULTILINESTRING";
                        geomtype = MULTILINETYPE ;
                        state->pgdims = 2;
                        break;
 
                case SHPT_POLYGON:
                        /* Polygon */
                        state->pgtype = "MULTIPOLYGON";
                        geomtype = MULTIPOLYGONTYPE;
                        state->pgdims = 2;
                        break;
 
                case SHPT_MULTIPOINT:
                        /* MultiPoint */
                        state->pgtype = "MULTIPOINT";
                        geomtype = MULTIPOINTTYPE;
                        state->pgdims = 2;
                        break;
 
                case SHPT_POINTM:
                        /* PointM */
                        geomtype = POINTTYPE;
                        state->has_m = 1;
                        state->pgtype = "POINTM";
                        state->pgdims = 3;
                        break;
 
                case SHPT_ARCM:
                        /* PolyLineM */
                        geomtype = MULTILINETYPE;
                        state->has_m = 1;
                        state->pgtype = "MULTILINESTRINGM";
                        state->pgdims = 3;
                        break;
 
                case SHPT_POLYGONM:
                        /* PolygonM */
                        geomtype = MULTIPOLYGONTYPE;
                        state->has_m = 1;
                        state->pgtype = "MULTIPOLYGONM";
                        state->pgdims = 3;
                        break;
 
                case SHPT_MULTIPOINTM:
                        /* MultiPointM */
                        geomtype = MULTIPOINTTYPE;
                        state->has_m = 1;
                        state->pgtype = "MULTIPOINTM";
                        state->pgdims = 3;
                        break;
 
                case SHPT_POINTZ:
                        /* PointZ */
                        geomtype = POINTTYPE;
                        state->has_m = 1;
                        state->has_z = 1;
                        state->pgtype = "POINT";
                        state->pgdims = 4;
                        break;
 
                case SHPT_ARCZ:
                        /* PolyLineZ */
                        state->pgtype = "MULTILINESTRING";
                        geomtype = MULTILINETYPE;
                        state->has_z = 1;
                        state->has_m = 1;
                        state->pgdims = 4;
                        break;
 
                case SHPT_POLYGONZ:
                        /* MultiPolygonZ */
                        state->pgtype = "MULTIPOLYGON";
                        geomtype = MULTIPOLYGONTYPE;
                        state->has_z = 1;
                        state->has_m = 1;
                        state->pgdims = 4;
                        break;
 
                case SHPT_MULTIPOINTZ:
                        /* MultiPointZ */
                        state->pgtype = "MULTIPOINT";
                        geomtype = MULTIPOINTTYPE;
                        state->has_z = 1;
                        state->has_m = 1;
                        state->pgdims = 4;
                        break;
 
                default:
                        state->pgtype = "GEOMETRY";
                        geomtype = COLLECTIONTYPE;
                        state->has_z = 1;
                        state->has_m = 1;
                        state->pgdims = 4;
 
                        snprintf(state->message, SHPLOADERMSGLEN, _("Unknown geometry type: %d\n"), state->shpfiletype);
                        return SHPLOADERERR;
 
                        break;
                }
 
                /* Force Z/M-handling if configured to do so */
                switch(state->config->force_output)
                {
                case FORCE_OUTPUT_2D:
                        state->has_z = 0;
                        state->has_m = 0;
                        state->pgdims = 2;
                        break;
 
                case FORCE_OUTPUT_3DZ:
                        state->has_z = 1;
                        state->has_m = 0;
                        state->pgdims = 3;
                        break;
 
                case FORCE_OUTPUT_3DM:
                        state->has_z = 0;
                        state->has_m = 1;
                        state->pgdims = 3;
                        break;
 
                case FORCE_OUTPUT_4D:
                        state->has_z = 1;
                        state->has_m = 1;
                        state->pgdims = 4;
                        break;
                default:
                        /* Simply use the auto-detected values above */
                        break;
                }
 
                /* If in simple geometry mode, alter names for CREATE TABLE by skipping MULTI */
                if (state->config->simple_geometries)
                {
                        if ((geomtype == MULTIPOLYGONTYPE) || (geomtype == MULTILINETYPE) || (geomtype == MULTIPOINTTYPE))
                        {
                                /* Chop off the "MULTI" from the string. */
                                state->pgtype += 5;
                        }
                }
 
        }
        else
        {
                /* Otherwise just count the number of records in the DBF */
                state->num_entities = DBFGetRecordCount(state->hDBFHandle);
        }
 
 
        /* Get the field information from the DBF */
        state->num_fields = DBFGetFieldCount(state->hDBFHandle);
 
        state->num_records = DBFGetRecordCount(state->hDBFHandle);
 
        /* Allocate storage for field information */
        state->field_names = malloc(state->num_fields * sizeof(char*));
        state->types = (DBFFieldType *)malloc(state->num_fields * sizeof(int));
        state->widths = malloc(state->num_fields * sizeof(int));
        state->precisions = malloc(state->num_fields * sizeof(int));
        state->pgfieldtypes = malloc(state->num_fields * sizeof(char *));
        state->col_names = malloc((state->num_fields + 2) * sizeof(char) * MAXFIELDNAMELEN);
 
        strcpy(state->col_names, "" );
        /* Generate a string of comma separated column names of the form "col1, col2 ... colN" for the SQL
           insertion string */
 
        for (int j = 0; j < state->num_fields; j++)
        {
                int field_precision = 0, field_width = 0;
                type = DBFGetFieldInfo(state->hDBFHandle, j, name, &field_width, &field_precision);
 
                state->types[j] = type;
                state->widths[j] = field_width;
                state->precisions[j] = field_precision;
/*              fprintf(stderr, "XXX %s width:%d prec:%d\n", name, field_width, field_precision); */
 
                if (state->config->encoding)
                {
                        char *encoding_msg = _("Try \"LATIN1\" (Western European), or one of the values described at http://www.gnu.org/software/libiconv/.");
 
                        int rv = utf8(state->config->encoding, name, &utf8str);
 
                        if (rv != UTF8_GOOD_RESULT)
                        {
                                if ( rv == UTF8_BAD_RESULT )
                                        snprintf(state->message, SHPLOADERMSGLEN, _("Unable to convert field name \"%s\" to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s"), utf8str, strerror(errno), state->config->encoding, encoding_msg);
                                else if ( rv == UTF8_NO_RESULT )
                                        snprintf(state->message, SHPLOADERMSGLEN, _("Unable to convert field name to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s"), strerror(errno), state->config->encoding, encoding_msg);
                                else
                                        snprintf(state->message, SHPLOADERMSGLEN, _("Unexpected return value from utf8()"));
 
                                if ( rv == UTF8_BAD_RESULT )
                                        free(utf8str);
 
                                return SHPLOADERERR;
                        }
 
                        strncpy(name, utf8str, MAXFIELDNAMELEN);
                        name[MAXFIELDNAMELEN-1] = '\0';
                        free(utf8str);
                }
 
                /* If a column map file has been passed in, use this to create the postgresql field name from
                   the dbf column name */
                {
                  const char *mapped = colmap_pg_by_dbf(&state->column_map, name);
                  if (mapped)
                  {
                          strncpy(name, mapped, MAXFIELDNAMELEN);
                          name[MAXFIELDNAMELEN-1] = '\0';
                        }
                }
 
                /*
                 * Make field names lowercase unless asked to
                 * keep identifiers case.
                 */
                if (!state->config->quoteidentifiers)
                        strtolower(name);
 
                /*
                 * Escape names starting with the
                 * escape char (_), those named 'gid'
                 * or after pgsql reserved attribute names
                 */
                if (name[0] == '_' ||
                    ! strcmp(name, "gid") ||
                    ! strcmp(name, "tableoid") ||
                    ! strcmp(name, "cmin") ||
                    ! strcmp(name, "cmax") ||
                    ! strcmp(name, "xmin") ||
                    ! strcmp(name, "xmax") ||
                    ! strcmp(name, "primary") ||
                    ! strcmp(name, "oid") ||
                    ! strcmp(name, "ctid"))
                {
                        char tmp[MAXFIELDNAMELEN] = "__";
                        memcpy(tmp+2, name, MAXFIELDNAMELEN-2);
                        tmp[MAXFIELDNAMELEN-1] = '\0';
                        strncpy(name, tmp, MAXFIELDNAMELEN);
                }
 
                /* Avoid duplicating field names */
                for (int z = 0; z < j; z++)
                {
                        if (strcmp(state->field_names[z], name) == 0)
                        {
                                strncat(name, "__", MAXFIELDNAMELEN - 1);
                                snprintf(name + strlen(name),
                                         MAXFIELDNAMELEN - 1 - strlen(name),
                                         "%i",
                                         j);
                                break;
                        }
                }
 
                state->field_names[j] = strdup(name);
 
                /* Now generate the PostgreSQL type name string and width based upon the shapefile type */
                switch (state->types[j])
                {
                case FTString:
                        state->pgfieldtypes[j] = strdup("varchar");
                        break;
 
                case FTDate:
                        state->pgfieldtypes[j] = strdup("date");
                        break;
 
                case FTInteger:
                        /* Determine exact type based upon field width */
                        if (state->config->forceint4 || (state->widths[j] >=5 && state->widths[j] < 10))
                        {
                                state->pgfieldtypes[j] = strdup("int4");
                        }
                        else if (state->widths[j] >=10 && state->widths[j] < 19)
                        {
                                state->pgfieldtypes[j] = strdup("int8");
                        }
                        else if (state->widths[j] < 5)
                        {
                                state->pgfieldtypes[j] = strdup("int2");
                        }
                        else
                        {
                                state->pgfieldtypes[j] = strdup("numeric");
                        }
                        break;
 
                case FTDouble:
                        /* Determine exact type based upon field width */
                        fprintf(stderr, "Field %s is an FTDouble with width %d and precision %d\n",
                                        state->field_names[j], state->widths[j], state->precisions[j]);
                        if (state->widths[j] > 18)
                        {
                                state->pgfieldtypes[j] = strdup("numeric");
                        }
                        else
                        {
                                state->pgfieldtypes[j] = strdup("float8");
                        }
                        break;
 
                case FTLogical:
                        state->pgfieldtypes[j] = strdup("boolean");
                        break;
 
                default:
                        snprintf(state->message, SHPLOADERMSGLEN, _("Invalid type %x in DBF file"), state->types[j]);
                        return SHPLOADERERR;
                }
 
                strcat(state->col_names, "\"");
                strcat(state->col_names, name);
 
                if (state->config->readshape == 1 || j < (state->num_fields - 1))
                {
                        /* Don't include last comma if its the last field and no geometry field will follow */
                        strcat(state->col_names, "\",");
                }
                else
                {
                        strcat(state->col_names, "\"");
                }
        }
 
        /* Append the geometry column if required */
        if (state->config->readshape == 1)
                strcat(state->col_names, state->geo_col);
 
        /* Return status */
        return ret;
}

References _, codepage2encoding(), shp_loader_state::col_names, COLLECTIONTYPE, colmap_pg_by_dbf(), colmap_read(), shp_loader_state::column_map, shp_loader_config::column_map_filename, shp_loader_state::config, DBFGetFieldCount(), DBFGetFieldInfo(), DBFGetRecordCount(), DBFOpen(), shp_loader_config::encoding, ENCODING_DEFAULT, shp_loader_state::field_names, shp_loader_config::force_output, FORCE_OUTPUT_2D, FORCE_OUTPUT_3DM, FORCE_OUTPUT_3DZ, FORCE_OUTPUT_4D, shp_loader_config::forceint4, free(), FTDate, FTDouble, FTInteger, FTInvalid, FTLogical, FTString, shp_loader_state::geo_col, shp_loader_state::has_m, shp_loader_state::has_z, shp_loader_state::hDBFHandle, shp_loader_state::hSHPHandle, lwfree(), malloc(), MAXFIELDNAMELEN, shp_loader_state::message, MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, shp_loader_config::null_policy, shp_loader_state::num_entities, shp_loader_state::num_fields, shp_loader_state::num_records, tagSHPObject::nVertices, shp_loader_state::pgdims, shp_loader_state::pgfieldtypes, shp_loader_state::pgtype, POINTTYPE, POLICY_NULL_ABORT, shp_loader_state::precisions, DBFInfo::pszCodePage, shp_loader_config::quoteidentifiers, shp_loader_config::readshape, shp_loader_config::shp_file, SHPDestroyObject(), shp_loader_state::shpfiletype, SHPGetInfo(), SHPLOADERERR, SHPLOADERMSGLEN, SHPLOADEROK, SHPLOADERWARN, SHPOpen(), SHPReadObject(), SHPT_ARC, SHPT_ARCM, SHPT_ARCZ, SHPT_MULTIPOINT, SHPT_MULTIPOINTM, SHPT_MULTIPOINTZ, SHPT_POINT, SHPT_POINTM, SHPT_POINTZ, SHPT_POLYGON, SHPT_POLYGONM, SHPT_POLYGONZ, shp_loader_config::simple_geometries, strtolower(), shp_loader_state::types, utf8(), UTF8_BAD_RESULT, UTF8_GOOD_RESULT, UTF8_NO_RESULT, and shp_loader_state::widths.

Referenced by main(), pgui_action_import(), and validate_remote_loader_columns().

Here is the call graph for this function:

Here is the caller graph for this function: