getTableInfo()

static int getTableInfo ( SHPDUMPERSTATE *  state )

static

Definition at line 874 of file pgsql2shp-core.c.

References _, shp_dumper_state::conn, free(), shp_dumper_state::geo_col_name, geometry_type_from_string(), LINETYPE, LWDEBUGF, lwtype_is_collection(), malloc(), shp_dumper_state::message, MULTILINETYPE, MULTIPOINTTYPE, MULTIPOLYGONTYPE, shp_dumper_state::outshptype, shp_dumper_state::outtype, POINTTYPE, POLYGONTYPE, window::res, shp_dumper_state::rowcount, shp_dumper_state::schema, SHPDUMPERERR, SHPDUMPERMSGLEN, SHPDUMPEROK, 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_dumper_state::table, and ovdump::type.

Referenced by ShpDumperOpenTable().

{

        /* Get some more information from the table:
                - count = total number of geometries/geographies in the table

           and if we have found a suitable geometry column:

                - max = maximum number of dimensions within the geometry/geography column
                - geometrytype = string representing the geometry/geography type, e.g. POINT

           Since max/geometrytype already require a sequential scan of the table, we may as
           well get the row count too.
         */

        PGresult *res;
        char *query;
        int tmpint;


        if (state->geo_col_name)
        {
                /* Include geometry information */
                if (state->schema)
                {
                        query = malloc(150 + 4 * strlen(state->geo_col_name) + strlen(state->schema) + strlen(state->table));

                        sprintf(query, "SELECT count(1), max(ST_zmflag(\"%s\"::geometry)), geometrytype(\"%s\"::geometry) FROM \"%s\".\"%s\" GROUP BY 3",
                        state->geo_col_name, state->geo_col_name, state->schema, state->table);
                }
                else
                {
                        query = malloc(150 + 4 * strlen(state->geo_col_name) + strlen(state->table));

                        sprintf(query, "SELECT count(1), max(ST_zmflag(\"%s\"::geometry)), geometrytype(\"%s\"::geometry) FROM \"%s\" GROUP BY 3",
                        state->geo_col_name, state->geo_col_name, state->table);
                }
        }
        else
        {
                /* Otherwise... just a row count will do */
                if (state->schema)
                {
                        query = malloc(40 + strlen(state->schema) + strlen(state->table));

                        sprintf(query, "SELECT count(1) FROM \"%s\".\"%s\"", state->schema, state->table);
                }
                else
                {
                        query = malloc(40 + strlen(state->table));

                        sprintf(query, "SELECT count(1) FROM \"%s\"", state->table);
                }
        }

        LWDEBUGF(3, "Table metadata query: %s\n", query);

        res = PQexec(state->conn, query);
        free(query);

        if (PQresultStatus(res) != PGRES_TUPLES_OK)
        {
                snprintf(state->message, SHPDUMPERMSGLEN, _("ERROR: Could not execute table metadata query: %s"), PQresultErrorMessage(res));
                PQclear(res);
                return SHPDUMPERERR;
        }

        /* Make sure we error if the table is empty */
        if (PQntuples(res) == 0)
        {
                snprintf(state->message, SHPDUMPERMSGLEN, _("ERROR: Could not determine table metadata (empty table)"));
                PQclear(res);
                return SHPDUMPERERR;
        }

        /* If we have a geo* column, get the dimension, type and count information */
        if (state->geo_col_name)
        {
                /* If a table has a geometry column containing mixed types then
                   the metadata query will return multiple rows. We need to cycle
                   through all rows to determine if the type combinations are valid.

                   Note that if we find a combination of a MULTI and non-MULTI geometry
                   of the same type, we always choose MULTI to ensure that everything
                   gets output correctly. The create_* conversion functions are clever
                   enough to up-convert the non-MULTI geometry to a MULTI in this case. */

                int dummy, i;
                uint8_t type = 0;
                int typefound = 0, typemismatch = 0;

                state->rowcount = 0;

                for (i = 0; i < PQntuples(res); i++)
                {
                        /* skip null geometries */
                        if (PQgetisnull(res, i, 2))
                        {
                                state->rowcount += atoi(PQgetvalue(res, i, 0));
                                continue;
                        }

                        geometry_type_from_string(PQgetvalue(res, i, 2), &type, &dummy, &dummy);

                        /* We can always set typefound to that of the first column found */
                        if (!typefound)
                                typefound = type;

                        switch (type)
                        {
                        case MULTIPOINTTYPE:
                                if (typefound != MULTIPOINTTYPE && typefound != POINTTYPE)
                                        typemismatch = 1;
                                else
                                        typefound = MULTIPOINTTYPE;
                                break;

                        case MULTILINETYPE:
                                if (typefound != MULTILINETYPE && typefound != LINETYPE)
                                        typemismatch = 1;
                                else
                                        typefound = MULTILINETYPE;
                                break;

                        case MULTIPOLYGONTYPE:
                                if (typefound != MULTIPOLYGONTYPE && typefound != POLYGONTYPE)
                                        typemismatch = 1;
                                else
                                        typefound = MULTIPOLYGONTYPE;
                                break;

                        case POINTTYPE:
                                if (typefound != POINTTYPE && typefound != MULTIPOINTTYPE)
                                        typemismatch = 1;
                                else if (!lwtype_is_collection(type))
                                        typefound = POINTTYPE;
                                break;

                        case LINETYPE:
                                if (typefound != LINETYPE && typefound != MULTILINETYPE)
                                        typemismatch = 1;
                                else if (!lwtype_is_collection(type))
                                        typefound = LINETYPE;
                                break;

                        case POLYGONTYPE:
                                if (typefound != POLYGONTYPE && typefound != MULTIPOLYGONTYPE)
                                        typemismatch = 1;
                                else if (!lwtype_is_collection(type))
                                        typefound = POLYGONTYPE;
                                break;
                        }

                        /* Update the rowcount for each type */
                        state->rowcount += atoi(PQgetvalue(res, i, 0));

                        /* Set up the dimension output type (note: regardless of how many rows
                                 the table metadata query returns, this value will be the same. But
                                 we'll choose to use the first value anyway) */
                        tmpint = atoi(PQgetvalue(res, i, 1));
                        switch (tmpint)
                        {
                        case 0:
                                state->outtype = 's';
                                break;
                        case 1:
                                state->outtype = 'm';
                                break;
                        default:
                                state->outtype = 'z';
                                break;
                        }

                }

                /* Flag an error if the table contains incompatible geometry combinations */
                if (typemismatch)
                {
                        snprintf(state->message, SHPDUMPERMSGLEN, _("ERROR: Incompatible mixed geometry types in table"));
                        PQclear(res);
                        return SHPDUMPERERR;
                }

                /* Set up the shapefile output type based upon the dimension information */
                switch (typefound)
                {
                case POINTTYPE:
                        switch(state->outtype)
                        {
                        case 'z':
                                state->outshptype = SHPT_POINTZ;
                                break;

                        case 'm':
                                state->outshptype = SHPT_POINTM;
                                break;

                        default:
                                state->outshptype = SHPT_POINT;
                        }
                        break;

                case MULTIPOINTTYPE:
                        switch(state->outtype)
                        {
                        case 'z':
                                state->outshptype = SHPT_MULTIPOINTZ;
                                break;

                        case 'm':
                                state->outshptype = SHPT_MULTIPOINTM;
                                break;

                        default:
                                state->outshptype = SHPT_MULTIPOINT;
                        }
                        break;

                case LINETYPE:
                case MULTILINETYPE:
                        switch(state->outtype)
                        {
                        case 'z':
                                state->outshptype = SHPT_ARCZ;
                                break;

                        case 'm':
                                state->outshptype = SHPT_ARCM;
                                break;

                        default:
                                state->outshptype = SHPT_ARC;
                        }
                        break;

                case POLYGONTYPE:
                case MULTIPOLYGONTYPE:
                        switch(state->outtype)
                        {
                        case 'z':
                                state->outshptype = SHPT_POLYGONZ;
                                break;

                        case 'm':
                                state->outshptype = SHPT_POLYGONM;
                                break;

                        default:
                                state->outshptype = SHPT_POLYGON;
                        }
                        break;
                }
        }
        else
        {
                /* Without a geo* column the total is simply the first (COUNT) column */
                state->rowcount = atoi(PQgetvalue(res, 0, 0));
        }

        /* Dispose of the result set */
        PQclear(res);

        return SHPDUMPEROK;
}

Here is the call graph for this function:

Here is the caller graph for this function: