Guía y consulta del usuario

ST_InteriorRingN

Devuelve el anillo interior número n de un polígono como una serie lineal. Los anillos no se organizan por orientación geométrica. Se organizan según las reglas definidas por las rutinas internas de verificación de geometrías. Así pues, el orden de los anillos no se puede predefinir.

Sintaxis

ST_InteriorRingN(p ST_Polygon, n Integer)

Tipo devuelto

db2gse.ST_LineString

Ejemplos

Un ornitólogo que está estudiando la población de aves de varias islas de los mares del sur sabe que la zona en la que se alimenta una determinada especie pasiva de aves está restringida a la orilla. Algunas de las islas contienen varios lagos. Las orillas de los lagos están habilitadas exclusivamente por especies de aves más agresivas. El ornitólogo sabe que, por cada isla, si el perímetro de los lagos supera un determinado umbral, las especies agresivas serán tan numerosas que amenazarán a las especies pasivas de la orilla. Por lo tanto, el ornitólogo necesita saber la suma de perímetros de los anillos interiores de las islas.


En la Figura 34, los anillos exteriores de las islas representan la interfaz ecológica que cada isla comparte con el mar. Algunas de las islas tienen lagos, que se representan mediante los anillos interiores de los polígonos.

Figura 34. Utilización de ST_InteriorRingN para determinar la longitud de las orillas dentro de cada isla


top

Las columnas ID y name de la tabla ISLANDS identifican cada isla, mientras que la columna de polígonos land almacena la geometría de la isla.

CREATE TABLE ISLANDS (id   integer,
                           name   varchar(32),
                      land  db2gse.ST_Polygon); 

El siguiente programa ODBC utiliza la función ST_InteriorRingN para extraer el anillo interior (lago) de cada polígono de islas como una serie lineal. El perímetro de la serie lineal que devuelve la función length se suma y se muestra junto con el ID de la isla.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#include "sg.h"
#include "sgerr.h"
#include "sqlcli1.h"
 
/***                        ***
 *** Cambiar estas constantes ***
 ***                        ***/
 
#define USER_NAME   "sdetest"   /* su nombre de usuario */
#define USER_PASS   "acid.rain" /* su contraseña de usuario */
#define DB_NAME     "mydb"      /* base de datos a la que se va a conectar */
 
static void check_sql_err (SQLHDBC  handle,
                           SQLHSTMT hstmt,
  LONG          rc,
                           CHAR     *str);
 
void main( argc, argv )
int argc;
char *argv[];
{
  SQLHDBC       handle;
  SQLHENV       henv;
  CHAR          sql_stmt[256];
  LONG          rc,
                total_perimeter,
                num_lakes,
                lake_number,
                island_id,
                lake_perimeter;
  SQLHSTMT      island_cursor,
                lake_cursor;
  SDWORD        pcbvalue,
                id_ind,
                lake_ind,
                length_ind;
 
/* Asignar memoria para el manejador de entorno ODBC henv e inicializar
la aplicación. */
 
  rc = SQLAllocEnv (&henv);
    if (rc != SQL_SUCCESS)
  {
    printf ("SQLAllocEnv failed with %d\n", rc);
    exit(0);
  }
 
/* Asignar memoria para un manejador de conexiones del entorno henv. */
 
  rc = SQLAllocConnect (henv, &handle);
    if (rc != SQL_SUCCESS)
  {
    printf ("SQLAllocConnect failed with %d\n", rc);
    exit(0);
  }
 
/* Cargar el controlador ODBC y conectar con la fuente de datos identificada
   por la base de datos, usuario y contraseña. */
 
  rc = SQLConnect (handle,
                   (UCHAR *)DB_NAME,
                   SQL_NTS,
                   (UCHAR *)USER_NAME,
                   SQL_NTS,
                   (UCHAR *)USER_PASS,
                   SQL_NTS);
 
  check_sql_err (handle, NULL, rc, "SQLConnect");
 
/* Asignar memoria al manejador de sentencia SQL island_cursor. */
 
  rc = SQLAllocStmt (handle, &island_cursor);
  check_sql_err (handle, NULL, rc, "SQLAllocStmt");
 
/* Preparar y ejecutar la consulta para obtener los ID de isla y el
   número de lagos (anillos interiores) */
 
  strcpy (sql_stmt, "select id, db2gse.ST_NumInteriorRings(land) from ISLANDS");
 
  rc = SQLExecDirect (island_cursor, (UCHAR *)sql_stmt, SQL_NTS);
  check_sql_err (NULL, island_cursor, rc, "SQLExecDirect");
 
/* Vincular la columna ID de la tabla con la variable island_id */
 
  rc = SQLBindCol (island_cursor, 1, SQL_C_SLONG, &island_id, 0, &id_ind);
  check_sql_err (NULL, island_cursor, rc, "SQLBindCol");
 
/* Vincular el resultado de numinteriorrings(land) con la variable num_lakes. */
 
  rc = SQLBindCol (island_cursor, 2, SQL_C_SLONG, &num_lakes, 0, &lake_ind);
  check_sql_err (NULL, island_cursor, rc, "SQLBindCol");
 
/* Asignar memoria al manejador de sentencia SQL lake_cursor. */
 
rc = SQLAllocStmt (handle, &lake_cursor);
  check_sql_err (handle, NULL, rc, "SQLAllocStmt");
 
/* Preparar la consulta para obtener la longitud de un anillo interior. */
 
  strcpy (sql_stmt,
          "select Length(db2gse.ST_InteriorRingN(land, cast (? as
integer))) from ISLANDS where id = ?");
 
  rc = SQLPrepare (lake_cursor, (UCHAR *)sql_stmt, SQL_NTS);
  check_sql_err (NULL, lake_cursor, rc, "SQLPrepare");
 
/* Vincular la variable lake_number como el primer parámetro de entrada */
 
  pcbvalue = 0;
  rc = SQLBindParameter (lake_cursor, 1, SQL_PARAM_INPUT, SQL_C_LONG,
       SQL_INTEGER, 0, 0, &lake_number, 0, &pcbvalue);
  check_sql_err (NULL, lake_cursor, rc, "SQLBindParameter");
 
/* Vincular island_id como el segundo parámetro de entrada */
 
  pcbvalue = 0;
  rc = SQLBindParameter (lake_cursor, 2, SQL_PARAM_INPUT, SQL_C_LONG,
       SQL_INTEGER, 0, 0, &island_id, 0, &pcbvalue);
  check_sql_err (NULL, lake_cursor, rc, "SQLBindParameter");
 
/* Vincular el resultado de Length(db2gse.ST_InteriorRingN(land, cast
  (? as integer))) a la variable lake_perimeter */
 
  rc = SQLBindCol (lake_cursor, 1, SQL_C_SLONG, &lake_perimeter, 0,
                   &length_ind);
  check_sql_err (NULL, island_cursor, rc, "SQLBindCol");
 
  /* Bucle externo, obtener id de islas y el número de lagos
  (anillos interiores) */
 
  while (SQL_SUCCESS == rc)
  {
    /* Buscar y cargar una isla */
 
    rc = SQLFetch (island_cursor);
 
    if (rc != SQL_NO_DATA)
    {
      check_sql_err (NULL, island_cursor, rc, "SQLFetch");
 
      /* Bucle interno, para esta isla obtener el perímetro de todos
         sus lagos (anillos interiores) */
 
      for (total_perimeter = 0,lake_number = 1;
           lake_number <= num_lakes;
           lake_number++)
      {
        rc = SQLExecute (lake_cursor);
        check_sql_err (NULL, lake_cursor, rc, "SQLExecute");
 
        rc = SQLFetch (lake_cursor);
        check_sql_err (NULL, lake_cursor, rc, "SQLFetch");
 
        total_perimeter += lake_perimeter;
 
        SQLFreeStmt (lake_cursor, SQL_CLOSE);
      }
    }
 
/* Mostrar el id de isla y el perímetro total de sus lagos. */
 
    printf ("Island ID = %d,  Total lake perimeter = %d\n",
             island_id,total_perimeter);
 
  }
 
  SQLFreeStmt (lake_cursor, SQL_DROP);
  SQLFreeStmt (island_cursor, SQL_DROP);
        SQLDisconnect (handle);
        SQLFreeConnect (handle);
  SQLFreeEnv (henv);
 
  printf( "\nTest Complete ...\n" );
 
}
 
static void check_sql_err (SQLHDBC handle, SQLHSTMT  hstmt, LONG rc,
                           CHAR *str)
{
 
    SDWORD dbms_err = 0;
    SWORD  length;
    UCHAR   err_msg[SQL_MAX_MESSAGE_LENGTH], state[6];
 
    if (rc != SQL_SUCCESS)
    {
      SQLError (SQL_NULL_HENV, handle, hstmt, state, &dbms_err,
                err_msg, SQL_MAX_MESSAGE_LENGTH - 1, &length);
      printf ("%s ERROR (%d): DBMS code:%d, SQL state: %s, message:
              \n %s\n", str, rc, dbms_err, state, err_msg);
 
      if (handle)
      {
        SQLDisconnect (handle);
        SQLFreeConnect (handle);
      }
      exit(1);
    }
}
 


[ Principio de página | Página anterior | Página siguiente | Contenido | Índice ]