Manual PostGIS

Manual PostGIS
Sumário
1. Introdução
1.1. Créditos
1.2. Mais Informações
2. Instalação
2.1. Exigências
2.2. PostGIS
2.2.1. Criando PostGIS habilitando espacialmente um banco de dados de modelo de
construção
2.2.2. Melhorias
2.2.3. Problemas Comuns
2.3. JDBC
2.4. Carregador/Descarregador
3. Perguntas Mais Frequentes
4. Usando PostGIS
4.1. Objetos GIS
4.1.1. Padrões de OpenGIS WKB e WKT
4.1.2. Padrões de PostGIS EWKB, EWKT e Forma Canônica
4.1.3. SQL-MM Parte 3
4.2. Usando Padrões de OpenGIS
4.2.1. Tabela de Sistemas de Referências Espacial (SPATIAL_REF_SYS)
4.2.2. Tabela de Colunas Geométricas (GEOMETRY_COLUMNS)
4.2.3. Criando uma Tabela de espacial
4.2.4. Assegurando-se conforme a geometria de OpenGIS
4.3. Carregando Dados de GIS
4.3.1. Usando SQL
4.3.2. Usando o Carregador
4.4. Recuperando Dados de GIS
4.4.1. Usando SQL
4.4.2. Usando o Descarregador
4.5. Construindo Índices
4.5.1. Índices GiST
4.5.2. Usando Índices
4.6. Queries Complexas
4.6.1. Vantagens no Uso de Índices
4.6.2. Exemplos de SQL Espacial
4.7. Usando Servidor de Mapas
4.7.1. Uso básico
4.7.2. Perguntas Mais Frequentes
4.7.3. Uso Avançado
4.7.4. Exemplos
4.8. Clientes de Java (JDBC)
4.9. Clientes de C (libpq)
4.9.1. Cursores de Texto
4.9.2. Cursores Binários
5. Tipos de Performance
5.1. Tabelas Pequenas de Geometrias Grandes
5.1.1. Descrição de problemas
5.1.2. Envolvimento com o trabalho
5.2. CLUSTERing em índices da geometria
5.3. Evitando a conversão da dimensão
6. Referência PostGIS
6.1. Funções de OpenGIS
6.1.1. Funções de Gerenciamento
6.1.2. Funções de Relacionamento da Geometria
6.1.3. Funções de Processamento da Geometria
6.1.4. Assessores Geométricos
6.1.5. Construtores Geométricos
6.2. Extensões PostGIS
6.2.2. Operadores
6.2.3. Funções de Medida
6.2.4. Saída Geométricas
6.2.6. Editores Geométricos
6.2.7. Referência Linear
6.2.8. Variado
6.2.9. Suporte a grandes transações (Long Transactions)
6.3. Funções SQL-MM
6.4. Funções ArcSDE
7. Relatando Erros
A. Apendice
A.1. Notas de Versão
A.1.1. Versão 1.2.1
A.1.2. Versão 1.2.0
A.1.3. Versão 1.1.6
A.1.4. Versão 1.1.5
A.1.5. Versão 1.1.4
A.1.6. Versão 1.1.3
A.1.7. Versão 1.1.2
A.1.8. Versão 1.1.1
A.1.9. Versão 1.1.0
A.1.10. Versão 1.0.6
A.1.11. Versão 1.0.5
A.1.12. Versão 1.0.4
A.1.13. Versão 1.0.3
A.1.14. Versão 1.0.2
A.1.15. Versão 1.0.1
A.1.16. Versão 1.0.0
A.1.17. Versão 1.0.0RC6
A.1.18. Versão 1.0.0RC5
A.1.19. Versão 1.0.0RC4
A.1.20. Versão 1.0.0RC3
A.1.21. Versão 1.0.0RC2
A.1.22. Versão 1.0.0RC1
PostGIS foi desenvolvido por Refractions Research Inc, como uma tecnologia de banco
de dados espacial no projeto de pesquisa. Refractions é uma companhia de consultoria
em GIS e banco de dados localizada em Victoria, British Columbia, Canadá, especializada
em integração de dados e desenvolvimento de software customizado. A finalidade deste
manual é de apoiar uma gama de funcionalidade de GIS importante, incluindo suporte
completo do OpenGIS, construção de topologia avançada (coberturas, superfícies, redes),
ferramentas de interface do usuário de mesa visando e editando dados de GIS, e
ferramentas de acesso baseadas na web.
1.1. Créditos
Sandro Santilli <strk@refractions.net>

Coordena todos os erros (bugs) fixando e mantendo o esforço, a integração de novas
funcionalidades GEOS, e novas funções.
Chris Hodgson <chodgson@refractions.net>

Mantem novos funções e suporte ao índice 7.2.
Paul Ramsey <pramsey@refractions.net>

Conserva a trilha da documentação e empacotamento.
Jeff Lounsbury <jeffloun@refractions.net>

Mantém o desenvolvimento original do Shape no programa de carga/descarga.
Dave Blasby <dblasby@gmail.com>

Dave, o principal desenvolvedor de PostGIS, mantém o lado de servidor de objetos e
suporte a índice, o lado de servidor de funções analíticas.
Outros contribuidores
Em ordem alfabética: Alex Bodnaru, Alex Mayrhofer, Bernhard Reiter, Bruce Rindahl,
Bruno Wolff III, Carl Anderson, Charlie Savage, David Skea, David Techer, IIDA Tetsushi,
Geographic Data BC, Gerald Fenoy, Gino Lucrezi, Klaus Foerster, Kris Jurka, Mark Cave-
Ayland, Mark Sondheim, Markus Schaber, Michael Fuhr, Nikita Shulga, Norman Vine,
Olivier Courtin, Ralph Mason, Steffen Macke.
Bibliotecas de suportes importante

A biblioteca das operações geométricas GEOS e o trabalho algorítmico de Martin Davis
<mbdavis@vividsolutions.com> de Vivid Solutions em fazê-la todas trabalharem.
A biblioteca de projeção cartográfica Proj4 e o trabalho de Gerald Evenden and Frank

Warmerdam em criá-la e mantê-la.
1.2. Mais Informações
• O software, a documentação e as novidades mais recentes do PostGIS estão

disponíveis no site, http://postgis.refractions.net.
• Mais informações sobre a biblioteca de operações geométricas GEOS está
disponível em http://geos.refractions.net.
• Mais informações sobre a biblioteca de reprojeção Proj4 está disponível em http://

www.remotesensing.org/proj.
• Mais informações sobre o servidor da banco de dados PostgreSQL está disponível

no site principal de PostgreSQL, http://www.postgresql.org.
• Mais informações sobre índice GiST está disponível no site de

desenvolvimento PostgreSQL GiST,http://www.sai.msu.su/~megera/postgres/gist.
• Mais informações sobre servidor de mapas na internet Mapserver está disponível

em http://mapserver.gis.umn.edu/.
• As "características simples para especificação do SQL " está disponível no

Consórcio de OpenGIS no site: http://www.opengis.org/.
Capítulo 2. Instalação
2.1. Exigências
PostGIS tem as seguintes exigências para construção e uso:
• Uma instalação completa do PostgreSQL (incluindo servidor de headers).

PostgreSQL está disponível em http://www.postgresql.org/. Versão 7.2 ou
posteriores.
• O compilador de GNU C (gcc). Alguns outros compiladores de C ANSI podem ser

usados para compilar PostGIS, mas foram achados poucos problemas ao compilar
com gcc.
• GNU Make (gmake ou make). Para muitos sistemas, GNU make é a versão default
que faz falta. Para saber a versão, utilizar make -v. Outras versões de make não
podem processar o PostGIS Makefile corretamente.
• (Opcional) Biblioteca de reprojeção Proj4. A biblioteca Proj4 é usada para fornecer

suporte a reprojeções coordenadas dentro de PostGIS. Proj4 está disponível para
baixa em http://www.remotesensing.org/proj.
• (Opcional) Biblioteca de geometria GEOS. A biblioteca GEOS é usada para

fornecer testes em geometria (Touches(), Contains(), Intersects()) e operações
(Buffer(), GeomUnion(), Difference()) com PostGIS. GEOS está disponível para
baixa em http://geos.refractions.net/.
•
2.2. PostGIS
O módulo de PostGIS é uma extensão ao PostgreSQL servidor de retaguarda. Assim,

PostGIS 1.2.1 requer um acesso completo do servidor de headers PostgreSQL
organizado em diretório para compilar. O código fonte PostgreSQL está disponível em
http://www.postgresql.org/.
PostGIS 1.2.1 pode ser construído com versões de PostgreSQL 7.2.0 ou posteriores. As
versões de PostgreSQL anteriores não são suportadas.
1. Antes de você compilar os módulos do servidor de PostGIS, terá que compilar e

instalar o pacote PostgreSQL.
Nota
Se você planeja usar funcionalidade de GEOS precisará unir PostgreSQL à
biblioteca de C++ padrão:
2. LDFLAGS=-lstdc++ ./configure [YOUR OPTIONS HERE]

3. Este é um trabalho voltado para exceções em C++ interando com ferramentas de
desenvolvimento mais antigas. Se você
perceber problemas estranhos (inesperadamente fechar uma retaguarda ou algo
semelhante), faça esta tentativa. Isso fará com que corra o risco de compilar o
PostgreSQL.
4. Para recuperar o arquivo fonte PostGIS faça nova baixa em http://

postgis.refractions.net/postgis-1.2.1.tar.gz. Descomprima o arquivo no diretório
"contrib" do fonte PostgreSQL, organizando assim, os fontes no diretório.
5. # cd [postgresql source tree]/contrib
6. # gzip -d -c postgis-1.2.1.tar.gz | tar xvf -
7. Entrar no diretório "postgis-1.2.1" e rodar:
8. # ./configure
9.
• Se quiser dar suporte a reprojeção de coordenada, deverá ter a biblioteca de
Proj4 instalada. Se ./configure não encontrá-la, tente usar --with-proj=PATH
para ajustar para um diretório específico da instalação Proj4.
• Se quiser usar funcionalidades GEOS, terá que ter instalada a biblioteca de
GEOS. Se ./configure não encontrá-la, tente usar --with-geos=PATH para
especificar o path completo para o programa geos-config path completo.
10.
11. Rodar o compilador e instalar comandos.
12. # make
13. # make install
14. Todos os arquivos são instalados usando informações fornecidas por pg_config.
• Bibliotecas são instaladas [pkglibdir]/lib/contrib.
• Arquivos de suporte importantes como lwpostgis.sql são instalados em

prefix]/share/contrib.
• Carregador e binários livres são instalados em [bindir]/.
15.
16. PostGIS requer para o PL/pgSQL extensão da linguagem procedural. Antes de
carregar o arquivo lwpostgis.sql, terá que habilitar primeiro o PL/pgSQL. Deverá
usar o comando createlang. O Guia de Programador PostgreSQL tem os detalhes,
caso queira executá-lo manualmente.
17. # createlang plpgsql [yourdatabase]

18. Carregar o objeto PostGIS e definir funções no banco de dados, carregando
definições de arquivo lwpostgis.sql.
19. # psql -d [yourdatabase] -f lwpostgis.sql

20. Extensões de servidor de PostGIS agora estão carregadas e prontas para uso.
21. Para um completo uso de coordenada de identificadores de definição de sistemas

EPSG, poderá tambem carregar o arquivo de definições spatial_ref_sys.sql e
conteúdos de tabela SPATIAL_REF_SYS.
22. # psql -d [yourdatabase] -f spatial_ref_sys.sql

2.2.1. Criando PostGIS habilitando espacialmente um modelo de construção de banco
de dados
Algumas distribuições empacotadas de PostGIS (em particular os instaladores Win32

para o PostGIS >= 1.1.5) carregam as funções de PostGIS dentro de um banco de dados
chamado template_postgis. Se o banco de dados template_postgis existir em sua
instalação de PostgreSQL, então é possível para usuários e/ou as aplicações, criarem
bancos de dados espacialmente habilitados, usando um único comando. Note que em
ambos os casos, o usuário do banco de dados terá um grande privilégio para criar novos
bancos de dados.
Do shell:
# createdb -T template_postgis my_spatial_db
Do SQL:
postgres=# CREATE DATABASE my_spatial_db

TEMPLATE=template_postgis
2.2.2. Atualização
Atualizando bancos de dados espacial existente pode ser complicado como requer a
recolocação ou a introdução de novas definições de objeto de PostGIS.
Infelizmente nem todas as definições podem ser substituídas facilmente em um banco de

dados vivo, assim às vezes sua melhor aposta são um processo de descarregar/carregar
(dump/reload).
PostGIS fornece uma proceduce SOFT UPGRADE para liberações menores ou de

pequenas correções (bugfix) e uma procedure HARD UPGRADE para liberações maiores.
Antes de tentar atualizar o postgis, é sempre válido fazer uma cópia dos seus dados.
Se usar o flag -Fc para pg_dump, estará apto a restaurar o descarregador com um HARD
UPGRADE.
2.2.2.1. Soft upgrade
Soft upgrade consiste do fonte de script lwpostgis_upgrade.sql em seu banco de dados

espacial:
$ psql -f lwpostgis_upgrade.sql -d your_spatial_database

Se um soft upgrade não for possível, o script abortará e será advertido sobre o HARD
UPGRADE que esá sendo requerido, assim não hesite tentar primeiro um soft upgrade.
Se um melhoramento macio não for possível o certificado abortar e você estará advertido
sobre o MELHORAMENTO DURO que está sendo requerido, assim que não hesitate
tentar primeiramente um melhoramento macio.
Note
Se você não encontrar o arquivo lwpostgis_upgrade.sql, estará usando uma versão

antereior a 1.1 e gerará esse arquivo por si mesmo. Isto é feito com o seguinte comando:
$ utils/postgis_proc_upgrade.pl lwpostgis.sql > lwpostgis_upgrade.sql

2.2.2.2. Hard upgrade
Por HARD UPGRADE pretendemos descarregar/carregar (dump/reload) do banco de

dados habilitando o postgis completo. Precisará de um HARD UPGRADE quando o
armazenamento interno dos objetos de postgis alterar ou quando o SOFT UPGRADE não
for possível. O apêndice Notas de Versão reportará para cada versão se você necessitar
descarregar/carregar (HARD UPGRADE) para atualizar.
PostGIS provides an utility script to restore a dump produced with the pg_dump -Fc
command. It is experimental so redirecting its output to a file will help in case of problems.
The procedure is as follow:
PostGIS fornece um script utilitário para restaurar uma descarga produzida com o
comando pg_dump -Fc. Assim, é experimental redirecionar sua saída para um arquivo
que o ajudará em caso de problemas. O procedimento é como segue:
Criar um "custom-format" para descarregar do banco de dados se quiser atualizar

(chamamos de "olddb").
$ pg_dump -Fc olddb > olddb.dump

Restaurar a descarga atualizando contextualmente postgis em um banco de dados novo.
O novo banco de dados não pode existir. postgis_restore aceita parâmetros createdb
depois da descarga de um nome de arquivo (file name) e isso pode por instância ser
usado se estiver usando o caracter enconding non-default para seu banco de dados.
Chamamos de “newdb”, com UNICODE como o caracter encoding:
$ sh utils/postgis_restore.pl lwpostgis.sql newdb olddb.dump -E=UNICODE > restore.log
Certificar-se de que todo objeto de descarga restaurado realmente tenha que ser
restaurado dda descarga e não entrar em conflito com esses definidos em lwpostgis.sql
$ grep ^KEEPING restore.log | less

Se atualizar de PostgreSQL < 8.0 para >= 8.0 poderá apagar o attrelid, o varattnum e as
colunas do stats na tabela dos geometry_columns, que não é mais necessário. Mantê-los
não terá problemas. DROPPING THEM WHEN REALLY NEEDED WILL DO HURT !
$ psql newdb -c "ALTER TABLE geometry_columns DROP attrelid"

$ psql newdb -c "ALTER TABLE geometry_columns DROP varattnum"
$ psql newdb -c "ALTER TABLE geometry_columns DROP stats"
A tabela spatial_ref_sys são recuperadas da descarga, para assegurar seus costumes
adicionais são mantidos, mas a distribuição pôde conter modificação como voce recupera
suas entradas, apagar a tabela e a fonte de uma nova. Se fizer adições, supomos que
conheça como recuperá-las antes de atualizar a tabela. Substituí-la com a nova é feita
desta forma:
$ psql newdb
newdb=> delete from spatial_ref_sys;
DROP
newdb=> \i spatial_ref_sys.sql
2.2.3. Problemas Comuns
Existem várias coisas para conferir quando sua instalação ou atualização não acontece
como você espera.
1. Será mais fácil se você descomprimir os arquivos de PostGIS no diretório "contrib"

do fonte PostgreSQL em árvore. Porém, se isto não for possível por alguma razão,
você poderá criar uma variável de desenvolvimento PGSQL_SRC para o caminho
do diretório fonte PostgreSQL Isto permitirá você compilar PostGIS, mas o
comando make install pode falhar, assim voce deverá estar preparado para copiar
a biblioteca de PostGIS e arquivos executáveis para os seus locais apropriados
você.
2. Verifique se você instalou PostgreSQL 7.2 ou mais novo, e então você estará
compilando mesma versão de fonte de PostgreSQL contra a versão de
PostgreSQL que está executando. Confusões podem ocorrer quando sua
distribuição (Linux) já instalou PostgreSQL, caso contrário, voce pode ter instalado
PostgreSQL antes e se esquecido disto. PostGIS só trabalhará com versões
PostgreSQL 7.2 ou mais novas. Mensagens de erros estranhas e inesperadas
resultarão se você usar uma versão mais velha. Para conferir a versão de
PostgreSQL que está executando, conecte-se ao banco de dados, usando psql e
execute o comando:
3. SELECT version();
4. Se rodar uma distribuição baseada RPM, voce pode verificar a existência de
pacotes pré-instaladores usando o comando rpm como segue:
rpm -qa | grep postgresql
Também verifique se fez qualquer alteração necessária do Makefile.config. Isto inclui:
1. Se quiser pode fazer reprojeções coordenadas, deverá instalar a biblioteca de
Proj4 em seu sistema, atribuir 1 a variável USE_PROJ e para seu prefixo de
instalação PROJ_DIR dentro de Makefile.config.
2. Se você quer estar hábil para usar funções de GEOS, deverá instalar a biblioteca
de GEOS em seu sistema, e atribuir 1 a variável USE_GEOS e para sua instalação
GEOS_DIR dentro de Makefile.config.
2.3. JDBC
As extensões de JDBC provêem de objetos de Java correspondentes aos tipos de

PostGIS internos. Estes objetos podem ser usados para gravar clientes Java, que
verificam o banco de dados de PostGIS e extraem ou fazem cálculos em dados de GIS
em PostGIS.
1. Entrar no sub-diretório de distribuição de PostGIS jdbc.
2. Editar Makefile para prover os caminhos corretos de seu compilador de java

(JAVAC) e interprete (JAVA).
3. Executar o comando make. Copiar o arquivo postgis.jar onde quer que mantenha
suas bibliotecas de java.
2.4. Carregador/Descarregador
Os dados para o carregador e descarregador são construídos e instalados

automaticamente, como parte da construção de PostGIS. Para construí-los e os instalá-
los manualmente, execute os comandos, conforme abaixo descritos:
# cd postgis-1.2.1/loader
# make
# make install
O carregador é chamado shp2pgsql e converte arquivos ESRI Shape em SQL apropriado
por carregar no PostGIS/PostgreSQL. O descarregador é chamado pgsql2shp e converte
tabelas PostGIS em arquivos ESRI Shape.
Capítulo 3. Perguntas Mais Frequentes
3.1. Que tipo de objetos geométricos eu posso armazenar?
Você pode armazenar point, linestring, polygon, multipoint, multiline, multipolygon, e

coleções geométricas. Estes são especificados Open GIS Well Known Text (com
extensões XYZ,XYM,XYZM).
3.2.
Como acrescentar um objeto de GIS no banco de dados?
Primeiro você precisa criar uma tabela com uma coluna de tipo "geometry" para carregar
os dados de GIS. Conecte seu banco de dados com psql e execute o comando SQL
seguinte:
CREATE TABLE gtest ( ID int4, NAME varchar(20) );

SELECT AddGeometryColumn('', 'gtest','geom',-1,'LINESTRING',2);
Se a adição de coluna de geometria falhar, você provavelmente não carregou as funções
e objetos de PostGIS dentro do banco de dados. Veja as instruções de instalação.
Então, você pode inserir uma geometria na tabela, usando inserção de declaração do
SQL .
O próprio objeto GIS é formatado usando o formato OpenGIS Consortium "well-known
text"
INSERT INTO gtest (ID, NAME, GEOM) VALUES (1, 'First Geometry',
GeomFromText('LINESTRING(2 3,4 5,6 5,7 8)', -1));
Para mais informação sobre outros objetos GIS, veja referência de objeto..
Para ver os dados de GIS na tabela:
SELECT id, name, AsText(geom) AS geom FROM gtest;

O valor de retorno deverá ser :
id | name | geom
----+----------------+-----------------------------
1 | First Geometry | LINESTRING(2 3,4 5,6 5,7 8)
(1 row)
3.3.
Como fazer uma seleção espacial?
É o mesmo caminho que constrói outras seleções de banco de dados, como uma
combinação SQL de retornos de valores, funções e teste verdadeiro ou falso.
Para fazer uma seleção espacial, existem dois caminhos que são importantes de se
manter em mente ao construir sua pergunta: pode fazer um índice espacial; e você faz
cálculos enormes em um grande número geometries.
No geral, se quiser usar operadores de interseção (&&) que testa se salto de caixa é de
interseção característica.O uso do operador && é útil porque se um índice espacial está
disponível à velocidade acima do teste, o operador && fará uso disto. Isto pode fazer as
seleções muito mais rápida.
Note que o salto de caixas usou a seleção que deve ser declarada explicitamente como
um box3d que usa o ":: box3d" que lança a operação.
Poderá também fazer uso de funções espaciais, como Distance(), Intersects(), Contains()
e Within(), entre outros, e obterá resultados abaixo de suas buscas.
A maior seleção espatial incluem ambos um teste posicionado e um teste de função

spatial. O teste do índice serve para limitar o número de retornos, somente eles que
podem se encontrar com a condição do interesse. As funções espaciais são então para
uso de teste de condição exata.
SELECT id, the_geom FROM thetable

WHERE
the_geom && 'POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))'
AND
Contains(the_geom,'POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))';
3.4.
Como fazer seleção espacial rápida em tabelas grandes?
Seleções rápidas em tabelas grandes é uma finalidade da existência propriamente de

bancos de dados espaciais (junto com suporte transacional), tendo assim, a importância
de um bom índice.
Para construir um índice espacial em uma tabela com uma coluna geometrica, use a
função
"CREATE INDEX" como segue:
CREATE INDEX [indexname] ON [tablename]

USING GIST ( [geometrycolumn] );
A opção "USING GIST" informa ao servidor para usar um índice GiST (Generalized
Searche Tree).
Nota
Índices GiST são assumidos para quem não sabe o que fazer com o dado. Índices para
esses dados soltos, chamado tambem de índices lossy, usa um objeto "proxy" (no caso
espacial, uma caixa delimitada) para construir o índice.
Deverá também assegurar-se de que se a seleção de PostgreSQL tiver muita informação

sobre seu índice para fazer decisões racionais, quando usá-lo. Para fazer isto, você tem
que pegar estatísticas em suas tabelas geométricas.
Para versões de PostgreSQL 8.0.x e superiores, rode o comando VACUUM ANALYZE.
Para versões de PostgreSQL 7.4.x e inferiores, rode o comando SELECT

UPDATE_GEOMETRY_STATS().
3.5.
Porque são descartados os índices PostgreSQL R-Tree?
Versões anteriores de PostGIS usaram os índices PostgreSQL R-Tree. Porém,
PostgreSQL R-Trees tem sido descartado completamente desde a versão 0.6, e índices
espaciais são proporcionados com esquema R-Tree-over-GiST.
Nossos testes mostraram velocidade de procura para R-Tree nativa e GiST serem
comparáveis. PostgreSQL R-Trees nativo tem duas limitações que os fazem indesejáveis
para o uso com características GIS (nota-se que estas limitações são devido a atual
implementação de PostgreSQL R-Tree nativa, não o conceito de R-Tree em geral):
• índices R-Tree em PostgreSQL não podem controlar características que são de

tamanhos maiores que 8K. Índices GiST podem, usando-se o "lossy" de
substituição a caixa delimitada para característica própria.
• índices R-Tree em PostgreSQL não são nenhuma "null safe" (sem segurança),
assim construindo um índice em uma coluna de geometria que contenha
geometrias nulas falharão.
3.6.
Porque usar a função AddGeometryColumn () e todas as funções restante de OpenGIS?
Se você não quer usar funções de suporte OpenGIS, não use. Simplesmente crie tabelas
com versões mais velhas dentro, definindo suas colunas de geometria na declaração do
CREATE . Todas suas geometrias terão SRIDs de valor -1, e os meta-dados de tabelas
OpenGIS não serão preenchidas corretamente. Porém, isto vai causar falhas na maioria
das aplicações baseadas em PostGIS, e geralmente é sugerido que você use
AddGeometryColumn () para criar tabelas de geometrias.
Mapserver é uma aplicação que faz uso dos meta-dados de geometry_columns.

Especificamente, Mapserver pode usar o SRID da coluna de geometria para fazer
características de reprojeções rápidas dentro da correta projeção de mapa.
3.7.
Qual é o melhor caminho para achar todos os objetos dentro de outro objeto de rádio?
Para se usar o banco de dados eficientemente, é melhor fazer uma seleção de rádio com
qual combina o teste de rádio com um teste de caixa de salto: o teste de caixa
delimitada usa o índice espacial, enquanto um subconjunto de dados de acesso rápido,
com o qual o teste de rádio é aplicado.
A função Expand() é uma maneira acessível de ampliar um salto de caixa para permitir
uma busca do índice de uma região do interesse. A combinação de uma cláusula do
índice do acesso rápido e de um teste exato mais lento da distância, fornece a melhor
combinação da velocidade e da precisão para esta seleção.
Por exemplo, procurar todos os objetos com 100 metros de POINT(1000 1000) a seleção
a seguir trabalharia bem:
SELECT *
FROM GEOTABLE
WHERE
GEOCOLUMN && Expand(GeomFromText('POINT(1000 1000)',-1),100)
AND
Distance(GeomFromText('POINT(1000 1000)',-1),GEOCOLUMN) < 100;
3.8.
Como executar uma reprojeção coordenada como parte de uma seleção?
Para executar uma reprojeção, a fonte e sistemas de coordenada de destino devem ser
definidos dentro da tabela SPATIAL_REF_SYS, e as geometrias que são reprojetadas já
devem ser usadas em atribuição do SRID. Uma vez isso terminado, uma reprojeção
é tão simples quanto recorrer ao destino desejado SRID.
SELECT Transform(GEOM,4269) FROM GEOTABLE;
Capítulo 4. Usando PostGIS
4.1. Objetos de GIS
Suporte PostGIS a objetos de GIS são "Simple Features" (Características Simples)

definidas pelo OpenGIS Consortium (OGC). Note que PostGIS suporta atualmente as
características e a representação de APIs, mas não as várias comparações e operadores
de convolução cedidos na especificação OGC "Simple Features for SQL".
PostGIS estende o padrão com suport para coordenadas 3DZ, 3DM e 4D.
4.1.1. Padrões de OpenGIS WKB e WKT
A especificação OpenGIS define dois caminhos padrões de objeto espacial de expressão:

a forma Well-Known Text (WKT) e a forma Well-Known Binary (WKB). Ambos, WKT and
WKB, incluem informação sobre o tipo do objeto e as coordenadas a qual forma o objeto.
Exemplos das representações de texto das características são como segue:
• POINT(0 0)
• LINESTRING(0 0,1 1,1 2)
• POLYGON((0 0,4 0,4 4,0 4,0 0),(1 1, 2 1, 2 2, 1 2,1 1))
• MULTIPOINT(0 0,1 2)
• MULTILINESTRING((0 0,1 1,1 2),(2 3,3 2,5 4))
• MULTIPOLYGON(((0 0,4 0,4 4,0 4,0 0),(1 1,2 1,2 2,1 2,1 1)), ((-1 -1,-1 -2,-2 -2,-2
-1,-1 -1)))
• GEOMETRYCOLLECTION(POINT(2 3),LINESTRING((2 3,3 4)))
A especificação de OpenGIS requer também que o formato de armazenamento interno de

objetos espaciais inclui um identificador de sistema referenciado espacial (SRID). O SRID
é requerido ao criar objetos espaciais para a inserção no banco de dados.
Input/Output desses formatos está disponível usando as seguintes relações:
bytea WKB = asBinary(geometry);

text WKT = asText(geometry);
geometry = GeomFromWKB(bytea WKB, SRID);
geometry = GeometryFromText(text WKT, SRID);
Por exemplo, uma declaração válida de inserção para criar e inserir um objeto espacial de
OGC seria::
INSERT INTO SPATIALTABLE (

THE_GEOM,
THE_NAME
)
VALUES (
GeomFromText('POINT(-126.4 45.32)', 312),
'A Place'
)
4.1.2. PostGIS Padrões EWKB, EWKT e Formas Canônicas
Somente o formato OGC suporta geometria 2d, e o SRID associado *nunca* faz parte das
respresentações do input/output.
Formatos de extensão Postgis são atualmente superset de um OGC(cada WKB/WKT

válido é um EWKB/EWKT válido), mas mas isto pôde variar no futuro, especificamente se
OGC saísse com um formato novo que opõe a nossas extensões. Assim você NÃO DEVE
confiar nesta característica!
Postgis EWKB/EWKT soma o suport a coordenadas 3dm,3dz,4d e faz parte das

informações SRID.
Exemplos das representações do texto (EWKT) dos objetos espaciais estendidos das
características são como segue:
• POINT(0 0 0) -- XYZ
• SRID=32632;POINT(0 0) -- XY with SRID
• POINTM(0 0 0) -- XYM
• POINT(0 0 0 0) -- XYZM
• SRID=4326;MULTIPOINTM(0 0 0,1 2 1) -- XYM with SRID

• MULTILINESTRING((0 0 0,1 1 0,1 2 1),(2 3 1,3 2 1,5 4 1))
• POLYGON((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0),(1 1 0,2 1 0,2 2 0,1 2 0,1 1 0))
• MULTIPOLYGON(((0 0 0,4 0 0,4 4 0,0 4 0,0 0 0),(1 1 0,2 1 0,2 2 0,1 2 0,1 1 0)),((-1
-1 0,-1 -2 0,-2 -2 0,-2 -1 0,-1 -1 0)))
• GEOMETRYCOLLECTIONM(POINTM(2 3 9),LINESTRINGM((2 3 4,3 4 5)))
Input/Output desses formatos são usados conforme a interface a seguir:
bytea EWKB = asEWKB(geometry);

text EWKT = asEWKT(geometry);
geometry = GeomFromEWKB(bytea EWKB);
geometry = GeomFromEWKT(text EWKT);
Por exemplo, uma declaração válida de inserção para criar e inserir um objeto espacial
seria:
INSERT INTO SPATIALTABLE (

THE_GEOM,
THE_NAME
)
VALUES (
GeomFromEWKT('SRID=312;POINTM(-126.4 45.32 15)'),
'lugar'
)
A "canonical form" (forma canônica ) de um tipo PostgreSQL são as representações que
pega com uma simples "query" (sem uma chamada de função) e no qual é garantido para
ser aceito com uma inserção simples, atualização ou cópia. Para o postgis tipo 'geometry'
são esses:
- Output -
binary: EWKB
ascii: HEXEWKB (EWKB in hex form)
- Input -
binary: EWKB
ascii: HEXEWKB|EWKT
Para o exemplo esta indicação lê EWKT e retorna HEXEWKB no processo do input/output

canônico do ascii:
=# SELECT 'SRID=4;POINT(0 0)'::geometry;

geometry
----------------------------------------------------
01010000200400000000000000000000000000000000000000
(1 row)
4.1.3. SQL-MM Part 3
A especificação Espacial de Aplicações de Multimedia do SQL estende as simples

características para especificações do SQL, definindo um número de curvas inseridas
circularmente.
As definições SQL-MM incluem coordenadas 3dm, 3dz e 4d, mas não permite embutir
informação SRID.
The well-known text extensions are not yet fully supported. Examples of some simple
curved geometries are shown below:
As extensões de texto conhecidas não são suportadas ainda por completo. Os exemplos
de algumas geometrias curvadas simples são mostrados abaixo:
• CIRCULARSTRING(0 0, 1 1, 1 0)
• COMPOUNDCURVE(CIRCULARSTRING(0 0, 1 1, 1 0),(1 0, 0 1))
• CURVEPOLYGON(CIRCULARSTRING(0 0, 4 0, 4 4, 0 4, 0 0),(1 1, 3 3, 3 1, 1 1))
• MULTICURVE((0 0, 5 5),CIRCULARSTRING(4 0, 4 4, 8 4))
• MULTISURFACE(CURVEPOLYGON(CIRCULARSTRING(0 0, 4 0, 4 4, 0 4, 0 0),(1
1, 3 3, 3 1, 1 1)),((10 10, 14 12, 11 10, 10 10),(11 11, 11.5 11, 11 11.5, 11 11)))
Nota
Atualmente, PostGIS não pode suportar o uso de curvas compostas (Compound Curves)
em um polígono curvo (Curve Polygon).
Nota
Todas as comparações do ponto flutuante dentro da implementação de SQL-MM

são executadas para uma tolerância especificada, atualmente 1E-8.
4.2. Usando Padrões de OpenGIS
O OpenGIS "Simple Features Specification for SQL" define tipos de objetos padrão GIS,
as funções requeridas para manipulá-las e uma especificação de tabela de meta-dados.
Para assegurar que os meta-dados permaneçam consistentes, operações como criar e
remover uma coluna espacial são carregadas fora através da definição procedures
especiais por OpenGIS.
E x i s t e m d u a s t a b e l a s d e m e t a - d a d o s O p e n G I S : S PAT I A L _ R E F _ S Y S e
GEOMETRY_COLUMNS. A tabela SPATIAL_REF_SYS carrega os identificadores
numéricos e descrições textuais de sistemas de coordenada usadas no banco de dados
espacial.
4.2.1. Tabela de Sistemas de Referências Espacial (SPATIAL_REF_SYS)
A definição da Tabela de Sistemas de Referências Espacial (SPATIAL_REF_SYS) é como

segue:
CREATE TABLE SPATIAL_REF_SYS (

SRID INTEGER NOT NULL PRIMARY KEY,
AUTH_NAME VARCHAR(256),
AUTH_SRID INTEGER,
SRTEXT VARCHAR(2048),
PROJ4TEXT VARCHAR(2048)
)
As colunas SPATIAL_REF_SYS são como segue:
SRID
Um valor inteiro que exclusivamente identifica o Sistema de Referência Espacial (Spacial
Referencing System - SRS) dentro do banco de dados.
AUTH_NAME
Nome do padrão ou corpo de padrões que estão sendo citados para este sistema de
referência. Por exemplo, "EPSG" seria um AUTH_NAME válido.
AUTH_SRID
O ID do Sistema de Referência Espacial (SRID) como definido pela autoridade citada no
AUTH_NAME. No caso de EPSG, é onde o código de projeção EPSG ficaria.
SRTEXT
Representação de Well-Known Text do Sistema de Referência Espacial (WKT SRS). Um
exemplo de uma representação WKT SRS é:
PROJCS["NAD83 / UTM Zone 10N",

GEOGCS["NAD83",
DATUM["North_American_Datum_1983",
SPHEROID["GRS 1980",6378137,298.257222101]
],
PRIMEM["Greenwich",0],
UNIT["degree",0.0174532925199433]
],
PROJECTION["Transverse_Mercator"],
PARAMETER["latitude_of_origin",0],
PARAMETER["central_meridian",-123],
PARAMETER["scale_factor",0.9996],
PARAMETER["false_easting",500000],
PARAMETER["false_northing",0],
UNIT["metre",1]
]
Para uma listagem de códigos de projeção Grupo de Exame Europeu do Petróleo (EPSG
- European Petroleum Survey Group) e suas correspondentes representações, veja http://
www.opengis.org/techno/interop/EPSG2WKT.TXT. Para uma discussão de WKT em geral,
veja OpenGIS "Coordinate Transformation Services Implementation Specification" em
http://www.opengis.org/techno/specs.htm. Para informações do Grupo de Exame Europeu
do Petróleo (EPSG - European Petroleum Survey Group) e seu banco de dados de
sistemas de referência espacial, veja: http://epsg.org/.
PROJ4TEXT
PostGIS usa a biblioteca Proj4 para fornecer potencialidades de
transformaçãocoordenadas . A coluna de PROJ4TEXT contem a string de definição de
coordenada Proj4 para um SRID particular. Por exemplo:
+proj=utm +zone=10 +ellps=clrk66 +datum=NAD27 +units=m

Para mais informações a respeito, veja a página de Proj4 em http://
www.remotesensing.org/proj. O arquivo spatial_ref_sys.sql contém ambas definições,
SRTEXT and PROJ4TEXT,para todas as projeções.
4.2.2. Tabela de Colunas Geométricas (GEOMETRY_COLUMNS)
A definição de Tabela de Colunas Geométricas (GEOMETRY_COLUMNS) é como segue:
CREATE TABLE GEOMETRY_COLUMNS (

F_TABLE_CATALOG VARCHAR(256) NOT NULL,
F_TABLE_SCHEMA VARCHAR(256) NOT NULL,
F_TABLE_NAME VARCHAR(256) NOT NULL,
F_GEOMETRY_COLUMN VARCHAR(256) NOT NULL,
COORD_DIMENSION INTEGER NOT NULL,
SRID INTEGER NOT NULL,
TYPE VARCHAR(30) NOT NULL
)
As colunas são como segue:
F_TABLE_CATALOG, F_TABLE_SCHEMA, F_TABLE_NAME

Nome completamente qualificado da característica tabela contendo a coluna geométrica.
Note que as condições "catalog" e "schema" são Oracle-ish.
Não existe análogo de "catalog" PostgreSQL de forma que a coluna é espaço em branco
a esquerda - para "schema" o nome de banco de dados PostgreSQL é usado. (public é o
default).
F_GEOMETRY_COLUMN
O nome da coluna geométrica na tabela característica
COORD_DIMENSION
Dimensão de espaço (2, 3 ou 4 dimensional) da coluna.
SRID
Identificador do sistema de referência espacial usado para a coordenada geométrica
nesta tabela. É uma chave de referência estrangeira para o SPATIAL_REF_SYS.
TYPE
Tipo do objeto espacial. Restringir a coluna espacial a um único tipo, usar um:
POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON,

GEOMETRYCOLLECTION or corresponding XYM versions POINTM, LINESTRINGM,
P O LY G O N M , M U LT I P O I N T M , M U LT I L I N E S T R I N G M , M U LT I P O LY G O N M ,
GEOMETRYCOLLECTIONM. Para coleções heterogêneas (mixed-type), você pode usar
"GEOMETRY" como tipo.
Nota
Este atributo não é (provavelmente) parte da especificação OpenGIS, mas é requerido

para homogeneidade de tipo assegurado.
4.2.3. Criando uma Tabela Espacial
Criação de uma tabela com dados espaciais é feito em duas fases:
• Criar uma tabela normal , ou seja, sem dados espacias.

Por exemplo: CREATE TABLE ROADS_GEOM ( ID int4, NAME varchar(25) )
Acrescentar uma coluna espacial para a tabela que usa a função OpenGIS
"AddGeometryColumn."
A sintaxe é:
• AddGeometryColumn(<schema_name>, <table_name>,
• <column_name>, <srid>, <type>,
• <dimension>)
• ou, usando "schema" corrente:
• AddGeometryColumn(<table_name>,
• <column_name>, <srid>, <type>,
• <dimension>)
•
Exemplo1: SELECT AddGeometryColumn('public', 'roads_geom', 'geom', 423,
'LINESTRING', 2)
Exemplo2: SELECT AddGeometryColumn( 'roads_geom', 'geom', 423,
'LINESTRING', 2)
Existe um exemplo de SQL usado para criar tabela e adicionar uma coluna espacial
(assumindo que um SRID de 128 já existe):
CREATE TABLE parks ( PARK_ID int4, PARK_NAME varchar(128), PARK_DATE date,

PARK_TYPE varchar(2) );
SELECT AddGeometryColumn('parks', 'park_geom', 128, 'MULTIPOLYGON', 2 );
Existe outro exemplo, usando o tipo "geometry" genérico e o indefinido SRID de valor -1:
CREATE TABLE roads ( ROAD_ID int4, ROAD_NAME varchar(128) );

SELECT AddGeometryColumn( 'roads', 'roads_geom', -1, 'GEOMETRY', 3 );
4.2.4. Assegurando-se conforme a geometria de OpenGIS
A maioria das funções executadas pela biblioteca de GEOS confiam na suposição que
suas geometrias são válidas como especificadas pela Especificação de Característica
Simples de OpenGIS (OpenGIS Simple Feature Specification). Para verificar a validade
das geometrias você pode usar a função IsValid():
gisdb=# select isvalid('LINESTRING(0 0, 1 1)'), isvalid('LINESTRING(0 0,0 0)');

isvalid | isvalid
---------+---------
t|f
Por default, PostGIS não aplica esta verificação de validade na entrada da geometria,
porque testar a validade necessita lotes de tempo do processador central (CPU) para
geometrias complexas, especialmente poligonos. Se não confiar em suas fontes de
dados, pode manualmente reforçar tal verificação a suas tabelas, adicionando um
confinamento da verificação:
ALTER TABLE mytable ADD CONSTRAINT geometry_valid_check CHECK

(isvalid(the_geom));
Se você encontrasse quaisquer mensagens de erro estranhas como "GEOS Intersection()
apresentou um erro!" ou "JTS Intersection() apresentou um erro!" quando chamar funções
PostGIS com entrada de geometrias válidas, você provavelmente encontrou um erro em
PostGIS ou em uma das bibliotecas de uso dele, e você deve contatar os colaboradores
de PostGIS. O mesmo é verdadeiro se uma função de PostGIS retornar uma geometria
inválida para a entrada válida.
Note
Estritamente as geometrias de OGC não podem ter valores de Z ou de M. A função válida

IsValid() não considerará geometrias altamente calculadas as dimensões inválidas!
Invocações de AddGeometryColumn() adicionará confinamente, verificando dimensões da
geometria, assim como é bastante para especificar.
4.3. Carregando Dados de GIS
Uma vez que você criou uma tabela espacial, você está pronto para atualizar os dados de
GIS no banco de dados. Atualmente, existem dois caminhos para entrar com os dados no
banco de dados PostGIS/PostgreSQL: usando declarações de SQL formatadas ou
usando o carregador/descarregador de arquivo Shape.
4.3.1. Usando SQL
Se você pode converter dados de uma representação de texto, então usando SQL
formatado poderia ser o modo mais fácil de entrar com seus dados em PostGIS. Como
com Oracle e outros bancos de dados de SQL, os dados podem ser carregados em
grandes quantidades e transportados em um grande arquivo de texto SQL cheio de
declarações de "INSERT" dentro do terminal SQL.
A carga de um arquivo de dados (roads.sql por exemplo) poderia se parecer como segue:
BEGIN;
I N S E RT I N TO R O A D S _ G E O M ( I D , G E O M , N A M E ) VA L U E S
(1,GeomFromText('LINESTRING(191232 243118,191108 243242)',-1),'Jeff Rd');
(2,GeomFromText('LINESTRING(189141 244158,189265 244817)',-1),'Geordie Rd');
(3,GeomFromText('LINESTRING(192783 228138,192612 229814)',-1),'Paul St');
(4,GeomFromText('LINESTRING(189412 252431,189631 259122)',-1),'Graeme Ave');
(5,GeomFromText('LINESTRING(190131 224148,190871 228134)',-1),'Phil Tce');
(6,GeomFromText('LINESTRING(198231 263418,198213 268322)',-1),'Dave Cres');
COMMIT;
O arquivo de dados pode ser transportado facilmente para dentro do PostgreSQL usando
o monitor de terminal SQL "psql":
psql -d [database] -f roads.sql

4.3.2. Usando o Carregador
O carregador de dados shp2pgsql converte arquivos ESRI Shape dentro do SQL de

maneira correta para inserção em um banco de dados de PostGIS/PostgreSQL. O
carregador tem vários modos operacionais distinguidos em linha de comando por
parametro:
-d
Exclui a tabela do banco de dados antes de criar uma nova tabela com os dados no
arquivo Shape.
-a
Acrescenta dados do arquivo Shape na tabela de banco de dados. Note que, para usar
esta opção para carregar arquivos múltiplos, os arquivos têm que ter os mesmos atributos
e mesmos tipos de dados.
-c
Cria uma nova tabela e insere dados do arquivo Shape. Este parametro é o modo padrão.
-p
Produz somente o código do SQL da criação da tabela, sem adicionar nenhum dado real.
Isto pode ser usado se você necessitar separar completamente as etapas da criação da
tabela e do carregamento dos dados.
-D
Cria uma nova tabela e insere dados do arquivo Shape. Este parametro usa o "dump"
formato PostgreSQL para os dados de produção e é muito mais rápido carregar que o
padrão "insert" formato SQL. Use isto para quantidades grandes de dados. Use o formato
do "dump" de PostgreSQL para os dados da saída. Isto pode ser combinado com - a, - o c
e - d. É muito mais rápido carregar do que o default de inserção do formato SQL. Use isto
para séries de dados muito grandes.
-s <SRID>
Cria e insere tabelas de geometria com o SRID especificado.
-k
Conserva identificadores de caso (coluna, schema e atributos). Note que os atributos em
Shapefile são todos UPPERCASE.
-i
Conserva identificadores de caso (coluna, schema e atributos). Note que os atributos em
Shapefile são todos UPPERCASE.
-w
Formato de saída WKT, para o uso com versões de PostGISanteriores (0.x). Note que isto
introduzirá trações coordenadas e deixará cair valores de M de shapefiles.
-W <encoding>
Specify encoding of the input data (dbf file). When used, all attributes of the dbf are
converted from the specified encoding to UTF8. The resulting SQL output will contain a
SET CLIENT_ENCODING to UTF8 command, so that the backend will be able to
reconvert from UTF8 to whatever encoding the database is configured to use internally.
Especificar codificando os dados de entrada (arquivo dbf). Quando usados, todos

os atributos do dbf são convertidos da codificação especificada
para UTF8. A saída resultante do SQL conterá um comando SET
CLIENT_ENCODING para UTF8, de modo que o retorno estará apto para uma
conversão de UTF8 para qualquer codificação de banco de dados que é
configurado para usar internamente.
Note que - a, - c, - d e - p é mutuamente exclusivo.
Uma sessão de exemplo que usa o carregador para criar um arquivo e carregá-lo poderia
ser como segue:
# shp2pgsql shaperoads myschema.roadstable > roads.sql

# psql -d roadsdb -f roads.sql
Podem ser feitos uma conversão e carga de tudo em um único comando, usando
caminhos (pipes) como no UNIX:
# shp2pgsql shaperoads myschema.roadstable | psql -d roadsdb

4.4. Recuperando Dados de GIS
Podem ser extraídos dados do banco de dados usando outro SQL ou o arquivo
carregador/descarregador Shape. No item SQL discutiremos alguns dos operadores
disponível para fazer comparações e selecionar tabelas espaciais.
4.4.1. Usando SQL
Os meios mais diretos de extrair dados do banco de dados são usar um SQL, para
selecionar dados e descarregar as colunas resultantes em um arquivo de texto:
db=# SELECT id, AsText(geom) AS geom, name FROM ROADS_GEOM;

id | geom | name
---+-----------------------------------------+-----------
1 | LINESTRING(191232 243118,191108 243242) | Jeff Rd
2 | LINESTRING(189141 244158,189265 244817) | Geordie Rd
3 | LINESTRING(192783 228138,192612 229814) | Paul St
4 | LINESTRING(189412 252431,189631 259122) | Graeme Ave
5 | LINESTRING(190131 224148,190871 228134) | Phil Tce
6 | LINESTRING(198231 263418,198213 268322) | Dave Cres
7 | LINESTRING(218421 284121,224123 241231) | Chris Way
(6 rows)
Porém, haverá restrições que será necessário reduzir o número de campos devolvido. No
caso de restrições atributos-baseados, usar exatamente a mesma sintaxe de SQL como
normal com uma tabela não espacial. No caso de restrições espaciais, os operadores
seguintes são habilitados/completos:
&&
Este operador diz se caixa delimitada de uma geometria sobrepõe caixa delimitada de
outra.
~=
Estes operadores testam se duas geometrias são geometricamente idênticas. Por
exemplo,se ' POLYGON((0 0,1 1,1 0,0 0)) ' está igual a ' POLYGON((0 0,1 1,1 0,0 0)) '.
=
Este operador é um pequeno mais ingênuo, só testa se as caixas delimitadas para
geometrias é o mesmo.
Logo, você pode usar estes operadores em questão. Note que ao especificar geometrias
e caixas na linha de comando SQL, você tem que transformar as representações de string
explicitamente em geometrias usando a função "GeometryFromText () ". Por exemplo:
SELECT
ID, NAME
FROM ROADS_GEOM
WHERE
GEOM ~= GeomFromText('LINESTRING(191232 243118,191108 243242)',-1);
A "query" anterior devolveria o único registro da tabela "ROADS_GEOM" pela qual a
geometria era igual aquele valor.
Ao usar o operador "&& ", pode especificar um outro BOX3D como característica de
comparação ou um GEOMETRY. Porém, quando você especifica um GEOMETRY que
sua caixa delimitada será usada para a comparação.
SELECT
ID, NAME
FROM ROADS_GEOM
WHERE
GEOM && GeomFromText('POLYGON((191232 243117,191232 243119,191234
243117,191232 243117))',-1);
A "query" anterior usará a caixa delimitada do polígono para propósitos de comparação.
A "query" espacial mais comum provavelmente será uma query "frame-based", usada por
cliente de software, como navegador de dados e mapas na web, pegar um valor de dados
"map-frame" para exibição. Usando um objeto "BOX3D" para a visualização, como
demonstrado como segue:
SELECT
AsText(GEOM) AS GEOM
FROM ROADS_GEOM
WHERE
GEOM && GeomFromText('BOX3D(191232 243117,191232 243119)'::box3d,-1);
Note que o uso do SRID, especifica a projeção do BOX3D. O valor -1 é usado para indicar
nenhum SRID especificado.
4.4.2. Usando o Descarregador
O descarregador de tabela pgsql2shp conecta diretamente ao banco de dados e converte

uma tabela em um arquivo Shape. A sintaxe básica é:
pgsql2shp [<options>] <database> [<schema>.]<table>

pgsql2shp [<options>] <database> <query>
As opções de linha de comando são:
-f <filename>
Escreva uma saída para um nome de arquivo particular.
-h <host>
O banco de dados do host para conectar.
-p <port>
A porta para conectar ao banco de dados do host.
-P <password>
A senha para usar a conexão do banco de dados.
-u <user>
O nome do usuário para usar a conexão do banco de dados.
-g <geometry column>
No caso de tabelas com colunas de geometria múltiplas, usar a coluna de geometria
quando escrever o arquivo Shape.
-b
Use um cursor binário. Isto fará a operação mais rápida, mas não trabalhará se qualquer
atributo da NON-geometry na tabela faltar um molde ao texto.
-r
Modalidade pura. Não destrua o campo "gid", ou nomes da coluna "escape".
-d
Para a compatibilidade inversa: escrever um arquivo shape 3-dimensional, quando
descarregar do banco de dados de postgis anteriores (pre-1.0.0) - o padrão é escrever um
arquivo Shape 2- dimensional neste caso). Inicie de postgis-1.0.0+, as dimensões são
codificadas inteiramente.
4.5. Construindo Índices
Índice é o que faz usando um banco de dados espacial para um possível bancos de
dados grandes. Sem indexação, nenhuma busca por característica requereria uma
procura sequencial de todo registro no banco de dados. Velocidades indexadas para cima
procurando os dados organizados em uma árvore de procura que pode ser atravessada
para achar um registro rapidamente. PostgreSQL apóia três tipos de índices através do
padrão:
Índices B-Trees, índices R-Trees e Índices GiST.
• B-Trees são usadas para dados que podem ser ordenados ao longo de um eixo;
por exemplo, números, cartas, datas. Dados de GIS não podem ser racionalmente
ordenados ao longo de um eixo (o qual é maior, (0,0) ou (0,1) ou (1,0)?) assim
indexação B-Tree é inútil para nós.
• R-Trees abre dados em retângulos, sub-retângulos, e sub-sub retângulos, etc. R-

Trees são
usados por alguns bancos de dados espaciais para indexar dados de GIS, mas
uma implementação R-Tree PostgreSQL não é como uma implementação robusta
de GiST.
• Índices GiST (Generalized Search Trees) abre dados em "things to one

side" (pense por um lado), "things which overlap" (coisas que sobreponham),
"things which are inside" (coisas que estão dentro) e podem ser usadas em uma
gama extensiva de tipos de dados, inclusive dados de GIS. PostGIS usa um índice
de R-Tree implementado em cima de GiST para indexar dados de GIS.
4.5.1. Índices GiST
GiST representa "Generalized Search Tree" e é uma forma generalizada de indexar. Além
da da indexação de GIS, GiST é usada para acelerar buscas em todos os tipos de
estruturas de dados irregulares (arranjos de números inteiros, dados espectrais, etc) que
não são amenos a indexação normal B-Tree.
Uma vez que uma tabela de dados de GIS excede algumas mil linhas, você poderá
construir um índice para buscas espaciais de dados (a menos que todas suas buscas
estejam baseadas em atributos, pelo qual você queira construir um índice normal nos
campos de atributo).
A sintaxe para construir um índice de GiST em uma coluna de geometria é como segue:
CREATE INDEX [indexname] ON [tablename]

USING GIST ( [geometryfield] GIST_GEOMETRY_OPS );
Construindo um índice espacial é um exercício computacionalmente intensivo: em tabelas
ao redor de 1 milhão de linhas, em uma máquina de 300MHz Solaris, achamos que com a
construção de um índice GiST leva aproximadamente 1 hora. Depois de construir um
índice, é importante forçar PostgreSQL a coletar estatísticas de tabela que são usadas
para otimizar planos de "query":
VACUUM ANALYZE [table_name] [column_name];
-- This is only needed for PostgreSQL 7.4 installations and below

SELECT UPDATE_GEOMETRY_STATS([table_name], [column_name]);
Índices GiST têm duas vantagens em relação a índices R-Tree em PostgreSQL. Em
primeiro lugar, índices GiST são "null safe" (segurança nula), significando que eles podem
indexar colunas que incluem valores nulos. Em segundo lugar, indices GiST apóiam o
conceito de "lossiness" que é importante quando lidado com objetos de GIS com páginas
PostgreSQL de tamanhos maiores que 8K. "Lossiness" permite PostgreSQL armazenar
somente a parte impor tante de um objeto em um índice - no caso de objetos de GIS, só a
caixa de saltos. Objetos de GIS maiores que 8K causarão índices R-Tree para falhar no
processo de ser construído.
4.5.2. Usando Índices
Índices aceleram o acesso de dados: uma vez que o índice é construído, a transparência
de planejamento de queries decide quando usar informação de índice para acelerar um
plano de "query". Infelizmente, a "query" PostgreSQL não planeja otimizar bem o uso de
índices de GiST, às vezes buscas que deveriam usar um índice espacial ao invés do
padrão para uma busca sequencial da tabela inteira.
Se você acha que seus índices espaciais não estão sendo usados (ou seus índices de
atributo, para aquele assunto) existe um agrupamento de coisas que você pode fazer:
• Primeiramente, certifique-se que as estatisticas são coletadas sobre o número e

distribuições dos valores em uma tabela, proporcionando para o operador de
"query", melhor informação de tomada de decisões em torno do uso de índices
Para instalações PostgreSQL 7.4 e anteriores, é rodado:
update_geometry_stats([table_name, column_name]) (agrupa estatísticas
distribuições de valores em uma tabela) e VACUUM ANALYZE [table_name]
[column_name] (agrupa estatísticas a respeito do número de valores em uma
tabela). Começando com PostgreSQL 8.0 rodando VACUUM ANALYZE fará ambas
as operações. Você deveria limpar regularmente seus bancos de dados - muitos
DBAs PostgreSQL têm rodado "VACUUM" (vazio) com a carga máxima de trabalho
"cron" desligada em bases regulares.
• Se não limpar seus trabalhos, você pode forçar o operador a usar informação de
índice utilizando o comando SET ENABLE_SEQSCAN=OFF. Você com certeza só
deveria usar este comando, em queries espacialmente indexadas: em geral, o
operador sabe melhor que você o que fazer a respeito, quando usar índices
normais de B-Tree. Uma vez que você rodou sua "query", você deveria considerar
a situação ENABLE_SEQSCAN atrás ligado, de maneira que outras queries o
operador utilizará como normal. Nota
A partir de versão 0.6, não deveria ser necessário forçar o operador a usar o índice
com ENABLE_SEQSCAN.
• Se você encontrar o operador errado sobre o custo de sequencial versus

varreduras de índice, tente reduzir o valor de "random_page_cost" em
postgresql.conf ou usando SET "random_page_cost"=#. O valor default para o
parâmetro é 4, tente ajustá-lo para 1 ou 2. Decremente o valor que faz o operador
mais inclinado, usando varreduras de índice.
4.6. Queries Complexas
A finalidade da existência propriamente para a funcionalidade do banco de dados
espacial está em executar queries dentro do banco de dados que deveria requerer
funcionalidade contidas em desktop GIS. Usando PostGIS efetivamente requer
conhecimento de quais funções espaciais estão disponíveis, e assegura-se que índices
apropriados estão em lugar que aprovam bom desempenho.
4.6.1. Vantagens dos Índices
Na construção de uma "query" é importante lembrarmos que os operadores baseados em

saltos de caixa tal como &&, pode tirar proveito do índice espacial de GiST. Funções como
distance () não pode usar o índice para otimizar suas operações. Por exemplo, a "query"
seguinte seria bastante lenta em uma tabela grande:
SELECT the_geom FROM geom_table

WHERE distance( the_geom, GeomFromText( 'POINT(100000 200000)', -1 ) ) < 100
Esta "query" está selecionando todas as geometrias em geom_table que está dentro de
100 unidades do ponto (100000, 200000). Estará lento porque está calculando a distância
entre cada ponto na tabela e nosso ponto especificado, ie. distance () calculados para
cada linha na tabela. Podemos evitar isto usando o operador && para reduzir o número de
cálculos de distância requerido:
SELECT the_geom FROM geom_table

WHERE the_geom && 'BOX3D(90900 190900, 100100 200100)'::box3d
AND distance( the_geom, GeomFromText( 'POINT(100000 200000)', -1 ) ) < 100
Esta "query" seleciona as mesmas geometrias, mas faz isto de um modo mais eficiente.
Supondo que existe um índice GiST em the_geom, o operador de "query" reconhecerá
que pode usar o índice para reduzir o número de linhas antes de calcular o resultado da
função distance ().
Note que a geometria de BOX3D que é usada dentro da operação && é uma caixa
quadrada centrada no ponto original unidade 200 - esta é nossa "query box". O operador
&& usa o índice para reduzir rapidamente o resultado atribuído a essas geometrias, que
têm salto de caixas que sobrepõem a "query box". Supondo que nossa "query box" é
muito menor que as extensões da tabela de geometria inteira, isto reduzirá drasticamente
o número de distância de cálculos que precisam ser feitos.
4.6.2. Exemplos de SQL Espacial
Os exemplos nesta seção utilizarão duas tabelas, uma tabela de estradas lineares, e uma
tabela de limites poligonal da municipalidade. As definições de tabela para a tabela dos
bc_roads são:
Column | Type | Description

------------+-------------------+-------------------
gid | integer | Unique ID
name | character varying | Road Name
the_geom | geometry | Location Geometry (Linestring)
A definição de tabela para a tabela do bc_municipality é:
Column | Type | Description

-----------+-------------------+-------------------
gid | integer | Unique ID
code | integer | Unique ID
name | character varying | City / Town Name
the_geom | geometry | Location Geometry (Polygon)
4.6.2.1. Qual o comprimento total de todas as estradas, expressado nos quilômetros?
4.6.2.2. Qual é a área da cidade de São Paulo, em hectares?
4.6.2.3. Qual é a maior municipalidade na província, por área?
4.6.2.4. Qual é o tamanho completo das estradas contidas inteiramente dentro de cada
municipalidade?
4.6.2.5. Críe uma nova tabela com todas as estradas dentro da cidade de São Paulo.
4.6.2.6. Qual é o tamanho em quilômetros, da Avenida dos Autonomistas, em OSASCO?
4.6.2.7. Qual é o maior polígono da municipalidade que tem uma regra?
4.6.2.1.
Qual o comprimento total de todas as estradas, expressado nos quilômetros?
Voce pode responder esta questão com uma parte muito simples de SQL:
postgis=# SELECT sum(length(the_geom))/1000 AS km_roads FROM bc_roads;

km_roads
------------------
70842.1243039643
(1 row)
4.6.2.2.
Qual é a área da cidade de São Paulo, em hectares?
Esta "query" combina uma condição do atributo (no nome da municipalidade) com um
cálculo espacial (da área):
postgis=# SELECT area(the_geom)/10000 AS hectares FROM bc_municipality

WHERE name = 'SÃO PAULO'
------------------
32657.9103824927
(1 row)
4.6.2.3.
Qual é a maior municipalidade na província, por área?
Esta "query" traz uma medida espacial na condição da "query". Há diversas maneiras de
avaliar este problema, mas o mais eficiente está abaixo:
postgis=# SELECT name, area(the_geom)/10000 AS hectares

FROM bc_municipality
ORDER BY hectares DESC
LIMIT 1;
name | hectares
---------------+-----------------
TUMBLER RIDGE | 155020.02556131
(1 row)
Note que a ordem para responder a esta "query", nós temos que calcular a área de cada
polígono. Se nós fizéssemos isto muito, teria sentido acrescentar uma coluna da área à
tabela, que nós poderíamos separadamente posicionar para o desempenho. Requisitando
os resultados em um sentido descendente, e por eles que usam o comando de
PostgreSQL "LIMIT", nós podemos facilmente extrair o maior valor, sem usar uma função
agregada como o max().
4.6.2.4.
Qual é o tamanho completo das estradas contidas inteiramente dentro de cada
municipalidade?
Este é um exemplo de um "spatial join" , porque nós estamos trazendo junto dados de
duas tabelas (que fazem juntar), mas estamos usando uma condição de interação
espacial ("contained") como a melhor condição de juntar do que a aproximação relacional
usual de juntar em uma chave comum:
postgis=# SELECT m.name, sum(length(r.the_geom))/1000 as roads_km

FROM bc_roads AS r,bc_municipality AS m
WHERE r.the_geom && m.the_geom
AND contains(m.the_geom,r.the_geom)
GROUP BY m.name
ORDER BY roads_km;
name | roads_km
----------------------------+------------------
SURREY | 1539.47553551242
VANCOUVER | 1450.33093486576
LANGLEY DISTRICT | 833.793392535662
BURNABY | 773.769091404338
PRINCE GEORGE | 694.37554369147
...
Esta "query" examina porque cada estrada na tabela é sumarizada no resultado final
(sobre as estradas 250K para nossa tabela do exemplo particular). Para menores
"overlays" (mil registros em cem) a resposta pode ser muito ráapida.
4.6.2.5.
Crie uma nova tabela com todas as estradas dentro da cidade de São Paulo.
Este é um exemplo de um "overlay", que examina em duas tabelas e saídas em uma nova
tabela, que consiste espacialmente "clipped" ou do corte de resultados. Ao contrário do
"spatial join" demonstrado acima, esta "query" cria realmente novas geometrias. Um
"overlay" é como um turbo-carregado de "spatial join", e é útil para um trabalho mais exato
da análise:
postgis=# CREATE TABLE pg_roads as

SELECT intersection(r.the_geom, m.the_geom) AS intersection_geom,
length(r.the_geom) AS rd_orig_length,
r.*
FROM bc_roads AS r, bc_municipality AS m
AND intersects(r.the_geom, m.the_geom)
AND m.name = 'SÃO PAULO';
4.6.2.6.
Qual é o tamanho em quilômetros, da Avenida dos Autonomistas, em OSASCO?
postgis=# SELECT sum(length(r.the_geom))/1000 AS kilometers

FROM bc_roads r, bc_municipality m
AND r.name = 'Avenida dos Autonomistas'
AND m.name = 'OSASCO';
kilometers
------------------
4.89151904172838
(1 row)
4.6.2.7.
Qual é o maior polígono da municipalidade que tem uma regra?
postgis=# SELECT gid, name, area(the_geom) AS area

FROM bc_municipality
WHERE nrings(the_geom) > 1
ORDER BY area DESC LIMIT 1;
gid | name | area
-----+--------------+------------------
12 | SPALLUMCHEEN | 257374619.430216
(1 row)
4.7. Usando Mapserver
O Minnesota Mapserver é um servidor Web Map na internet que adapta-se a

especificação do Servidor de Mapas na Internet OpenGIS .
• A homepage do Mapserver está em http://mapserver.gis.umn.edu/.
• A especificação de Web Map OpenGIS está em http://www.opengis.org/techno/

specs/01-047r2.pdf.
4.7.1. Uso Básico
Usar PostGIS com Mapserver, você precisará conhecer como configurar o Mapserver que
está além da extensão desta documentação. Esta seção cobrirá distribuição e detalhes de
configuração de PostGIS específico.
Usar PostGIS com Mapserver, você precisará:
• Versão 0.6 ou posterior de PostGIS.
• Versão 3.5 ou posterior de Mapserver.

Mapserver acessa dados de PostGIS/PostgreSQL como qualquer outro cliente de
PostgreSQL- usando libpq. Estes meios que Mapserver pode ser instalado em qualquer
máquina com acesso de rede para o servidor de PostGIS, enquanto o sistema tem
bibliotecas client de PostgreSQL libpq.
1. Compile e instale Mapserver, com qualquer opções que você deseje, inclusive a
opção de configuração "-with-postgis"
2. Em seu arquivo de mapas Mapserver, acrescente uma camada de PostGIS. Por

exemplo:
3. LAYER
4. CONNECTIONTYPE postgis
5. NAME "widehighways"
6. # Connect to a remote spatial database
7. CONNECTION "user=dbuser dbname=gisdatabase host=bigserver"
8. # Get the lines from the 'geom' column of the 'roads' table
9. DATA "geom from roads"
10. STATUS ON
11. TYPE LINE
12. # Of the lines in the extents, only render the wide highways
13. FILTER "type = 'highway' and numlanes >= 4"
14. CLASS
15. # Make the superhighways brighter and 2 pixels wide
16. EXPRESSION ([numlanes] >= 6)
17. COLOR 255 22 22
18. SYMBOL "solid"
19. SIZE 2
20. END
21. CLASS
22. # All the rest are darker and only 1 pixel wide
23. EXPRESSION ([numlanes] < 6)
24. COLOR 205 92 82
25. END
26. END
27. No exemplo acima, as diretivas de especificação do PostGIS são como segue:
CONNECTIONTYPE
Para camadas de PostGIS, este é sempre "postgis."
CONNECTION
A conexão de banco de dados é governada por uma 'connection string' do qual é
um padrão de coleção de chaves e valores como este (com os valores padrões em
<>):
user=<username> password=<password> dbname=<username>
hostname=<server> port=<5432>
Um fio de conexão vazio ainda é válido, e nenhum dos pares de chave/valor
podem ser omitido. No mínimo você se proverá do nome e usuário do banco de
dados com c conexão.
DATA
A forma deste parâmetro é "< column> from <tablename>" onde a coluna é a
coluna espacial a ser traduzida no mapa.
FILTER
O filtro deve ser uma string SQL válida correspondendo à lógica que normalmente
segue da palavra-chave "WHERE" em uma "query" SQL. Por exemplo, assim fazer
só estradas com 6 ou mais pistas, use um filtro de "num_lanes >= 6."
28. Em seu banco de dados espacial, assegure-se que você tem índices espaciais
(GiST) construídos para qualquer das camadas que você estará desenhando.
29. CREATE INDEX [indexname]

30. ON [tablename]
31. USING GIST ( [geometrycolumn] GIST_GEOMETRY_OPS );
32. Se você estivesse examinando suas camadas usando Mapserver você também
precisaria de um "oid index."
Mapserver requer identificadores únicos para cada registro espacial ao fazer
queries, e o módulo de Mapserver PostGIS usa o valor oid PostgreSQL para prover
estes identificadores únicos. Um efeito colateral disto é que para fazer acesso
randômico rápido de registros durante queries, um "oid index" é necessário.
Construir um "oid index", use o SQL seguinte:
33. CREATE INDEX [indexname] ON [tablename] ( oid );

4.7.2. Perguntas Mais Frequentes
4.7.2.1. Quando eu uso uma EXPRESSÃO em meu arquivo de mapa, a condição nunca
retorna como verdadeira, mesmo que eu saiba os valores existentes em minha tabela.
4.7.2.2. O FILTRO que eu me uso para meus arquivos Shape não está trabalhando para
minha tabela de PostGIS de mesmos dados.
4.7.2.3. A extração da camada de PostGIS é muito mais lenta do que a camada do
arquivo Shape, é este normal?
4.7.2.4. A extração da camada de PostGIS é fina, mas as queries são realmente lentas. O
que está errado?
4.7.2.1.
Quando eu uso uma EXPRESSÃO em meu arquivo de mapa, a condição nunca retorna
como verdadeira, mesmo que eu saiba os valores existentes em minha tabela.
Ao contrário dos arquivos Shape, os nomes de campo de PostGIS têm que ser
referenciado nas expressões usando um caso mais baixo.
EXPRESSION ([numlanes] >= 6)

4.7.2.2.
O FILTRO que eu me uso para meus arquivos Shape não está trabalhando para minha
tabela de PostGIS de mesmos dados.
Ao contrário dos arquivos Shape, filtros para camadas de PostGIS usa a sintaxe SQL (são
adicionados à declaração do SQL o conector de PostGIS que extrai camadas em
Mapserver).
FILTER "type = 'highway' and numlanes >= 4"

4.7.2.3.
A extração da camada de PostGIS é muito mais lenta do que a camada do arquivo
Shape, é este normal?
Em geral, espera-se camadas de PostGIS serem 10% mais lenta do que camadas de
arquivos Shape, devido o "overhead" extra envolvido em conexões do banco de dados,
em transformações de dados e trânsito de dados entre o banco de dados e o Mapserver.
Se você estiver encontrando problemas substanciais de desempenho, é provável que

você não tem a configuração, um índice espacial em sua tabela.
postgis# CREATE INDEX geotable_gix ON geotable USING GIST ( geocolumn );

postgis# SELECT update_geometry_stats(); -- For PGSQL < 8.0
postgis# VACUUM ANALYZE; -- For PGSQL >= 8.0
4.7.2.4.
A extração da camada de PostGIS é fina, mas as queries são realmente lentas. O que
está errado?
Para que as "queries" sejam rápidas, você deve ter uma chave original para sua tabela
espacial e você deve ter um índice nessa chave original.
Você pode especificar que chave original para o Mapserver usar com a cláusula "USING
UNIQUE" em sua linha de dados:
DATA "the_geom FROM geotable USING UNIQUE gid"

Se sua tabela não tiver uma coluna original explícita, você pode usar "fake" para uma
única coluna usando a linha de PostgreSQL "oid" para sua coluna original. "oid" é a
coluna original "default" se você não declarar um, assim que reforçar sua velocidade da
"query", um problema de construção em índice no valor "oid" de sua tabela espacial.
postgis# CREATE INDEX geotable_oid_idx ON geotable (oid);

4.7.3. Uso Avançado
A cláusula USING pseudo-SQL é usada para acrescentar alguma informação para ajudar
a entender os resultados mapserver de maior complexidade das queries. Mais
especificamente, quando uma visão ou um subselect é usado como tabela fonte (a uso
certo de "FROM" em uma definição de DATA) é mais difícil para mapserver que
automaticamente determina um identificador único para cada linha e também o SRID
para a tabela. A cláusula USING pode proporcionar para mapserver estes dois tipos de
informação como segue:
DATA "the_geom FROM (SELECT table1.the_geom AS the_geom, table1.oid AS oid,

table2.data AS data
FROM table1 LEFT JOIN table2 ON table1.id = table2.id) AS new_table USING UNIQUE
oid USING SRID=-1"
USING UNIQUE <uniqueid>
Mapserver requer um id único para cada linha para identificar a linha quando esboça
queries. Normalmente, usaria o oid como identificador único, mas views e subselects não
tem automaticamente uma coluna "oid". Se você quiser usar a funcionalidade de "query"
de Mapserver, você precisa acrescentar uma única coluna para "views" ou "subselects" , e
declará-la com USING UNIQUE. Por exemplo, você poderia selecionar um valor para
"oid" da própria tabela para este propósito, ou nenhuma coluna que é garantido ser único
para o resultado final.
A declaração USING também pode ser muito útil para declarações de dados simples, se
você esboçando "queries". Recomendavasse previamente que, para acrescentar um
índice na coluna oid das tabelas usadas nas camadas "query-able", em ordem acelara o
desempenho de "queries" de mapa. Porém, com a cláusula USING, é possível dizer que
para o mapserver usa chave primária em suas próprias tabelas como o identificador de
"queries" de mapa, e então necessariamente não ter o mais longo índice adicional.
Nota
Examinando um mapa (Quering a Map) é a ação de "clicking" em um mapa e questionar

informações a respeito de características de mapa naquele local. Não confunda "map
queries" com o "query" SQL em uma definição DATA.
USING SRID=<srid>
PostGIS necessita saber qual referenciamento de sistema espacial que está sendo usado
pelas geometrias em ordem para que devolva os dados corretos atrás do mapserver.
Normalmente é possível encontrar esta informação dentro da tabela "geometry_columns"
no banco de dados de PostGIS, porém, isto não é possível para tabelas que são criadas
superficialmente como "view"s e "subselects". Assim o USING SRID= opção que permite
o correto SRID ser especificado na definição DATA.
Aviso
O parceiro para camadas de PostGIS Mapserver é razoavelmente primitivo, e é caso

sensível em algumas áreas. Tenha cuidado para assegurar-se de que todos as palavras
chaves do SQL e todas suas cláusulas USING estejam em caso superior, e que sua
cláusula USING UNIQUE precede sua cláusula "USING SRID.
4.7.4. Exemplos
Começamos com um exemplo simples e que levanta nosso trabalho. Considere a seguir a
definição de camada de Mapserver:
LAYER
CONNECTIONTYPE postgis
NAME "roads"
CONNECTION "user=theuser password=thepass dbname=thedb host=theserver"
DATA "the_geom FROM roads"
STATUS ON
TYPE LINE
CLASS
COLOR 0 0 0
END
END
Esta camada exibirá todas as geometrias de estrada na tabela de estradas com linhas
pretas.
Agora dizemos que nós queremos mostrar só as rodovias até que nós conseguirmos
fechar a câmara em pelo menos 1:100000 balança – as próximas duas camadas obterão
este efeito:
LAYER
MINSCALE 100000
STATUS ON
TYPE LINE
FILTER "road_type = 'highway'"
CLASS
COLOR 0 0 0
END
END
LAYER
MAXSCALE 100000
STATUS ON
TYPE LINE
CLASSITEM road_type
CLASS
EXPRESSION "highway"
SIZE 2
COLOR 255 0 0
END
CLASS
COLOR 0 0 0
END
END
A primeira camada é usada quando a balança é maior que 1:100000, e exibe só as
estradas de tipo "highway" (rodovia) com linhas pretas. A opção FILTER causa só
estradas de TIPO "highway" (rodovia) a ser exibida.
A segunda camada é usada quando a balança é menos que 1:100000, e exibirá rodovias
como linhas vermelhas grossas, e outras estradas como linhas pretas regulares.
Assim, nós fizemos um par de coisas interessantes que usam só funcionalidade de

mapserver, mas nossa declaração DATA SQL permaneceu simples. Suponha que o nome
da estrada é armazenado em outra tabela (por qualquer razão) e nós precisamos fazer
um una adquirir isto e etiquetar nossas estradas.
LAYER
DATA "the_geom FROM (SELECT roads.oid AS oid, roads.the_geom AS the_geom,
road_names.name as name
FROM roads LEFT JOIN road_names ON roads.road_name_id =
road_names.road_name_id) AS named_roads
USING UNIQUE oid USING SRID=-1"
MAXSCALE 20000
STATUS ON
TYPE ANNOTATION
LABELITEM name
CLASS
LABEL
ANGLE auto
SIZE 8
COLOR 0 192 0
TYPE truetype
FONT arial
END
END
END
Esta camada da anotação adiciona etiquetas verdes a todas as estradas quando a escala
começa para baixo a 1:20000 ou menos. Demonstra também como usar um "join" SQL
em uma definição DATA.
4.8. Clientes Java (JDBC)
Os clientes de Java podem acessar objetos da "geometria" de PostGIS no banco de

dados de PostgreSQL, outros diretamente como representações de texto ou usam os
objetos de extensão JDBC empacotados com PostGIS. A fim usar os objetos de extensão,
o arquivo "postgis.jar" deve estar em seu CLASSPATH junto com o pacote JDBC de
"postgresql.jar".
import java.sql.*;
import java.util.*;
import java.lang.*;
import org.postgis.*;
public class JavaGIS {

public static void main(String[] args)
{
java.sql.Connection conn;
try
{
/*
* Load the JDBC driver and establish a connection.
*/
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/database";
conn = DriverManager.getConnection(url, "postgres", "");
/*
* Add the geometry types to the connection. Note that you
* must cast the connection to the pgsql-specific connection * implementation before
calling the addDataType() method.
*/
((org.postgresql.Connection)conn).addDataType("geometry","org.postgis.PGgeometry");
((org.postgresql.Connection)conn).addDataType("box3d","org.postgis.PGbox3d");
/*
* Create a statement and execute a select query.
*/
Statement s = conn.createStatement();
ResultSet r = s.executeQuery("select AsText(geom) as geom,id from geomtable");
while( r.next() )
{
/*
* Retrieve the geometry as an object then cast it to the geometry type.
* Print things out.
*/
PGgeometry geom = (PGgeometry)r.getObject(1);
int id = r.getInt(2);
System.out.println("Row " + id + ":");
System.out.println(geom.toString());
}
s.close();
conn.close();
}
catch( Exception e )
{
e.printStackTrace();
}
}
}
O objeto "PGgeometry" é um objeto "wrapper" que contem um objeto de geometria
topológico específico (subclasses da classe "geometria") dependendo do tipo: Point,
LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon.
PGgeometry geom = (PGgeometry)r.getObject(1);

if( geom.getType() = Geometry.POLYGON )
{
Polygon pl = (Polygon)geom.getGeometry();
for( int r = 0; r < pl.numRings(); r++ )
{
LinearRing rng = pl.getRing(r);
System.out.println("Ring: " + r);
for( int p = 0; p < rng.numPoints(); p++ )
{
Point pt = rng.getPoint(p);
System.out.println("Point: " + p);
System.out.println(pt.toString());
}
}
}
O JavaDoc para os objetos da extensão fornece uma referência para as várias funções do
assessor dos dados nos objetos geométricos.
4.9. Clientes C (libpq)
...
4.9.1. Cursores de Texto
...
4.9.2. Cursores Binários
...
Capítulo 5. Tipos de Performance
5.1. Tabelas pequenas de geometrias grandes
5.1.1. Descrição de problemas
As versões atuais de PostgreSQL (incluindo 8.0) sofrem de uma fraqueza do otimizador

da "query" a respeito das tabelas "TOAST". As tabelas "TOAST" são um tipo "extension
room" usado para armazenar (no sentido do tamanho dos dados) os valores que não
cabem em páginas de dados normais(como textos longos, imagens ou geometrias
complexas com lotes de vertices), vejam http://www.postgresql.org/docs/8.0/static/storage-
toast.html, para mais informações.
O problema aparece se acontecer de ter uma tabela com geometrias de preferência

grandes, mas não com muitas linhas (como uma tabela que contem os limites de todos os
países europeus em resolução elevada). Então a própria tabela é pequena, mas usa lotes
de espaço do "TOAST". Neste exemplo, a própria tabela teve aproximadamente 80 linhas
e usa somente 3 páginas de dados, mas a tabela "TOAST" usou 8225 páginas.
Agora emita uma "query" onde você use o operador de geometria && procurar por salto
de caixa aqueles só os poucos grupos daquelas linhas. Agora a "query" otimizada vê que
a tabela tem somente 3 páginas e 80 linhas. Estima que uma varredura seqüencial em
uma tabela tão pequena é muito mais rápida do que usando um índice. E assim decide-se
ignorar o índice de GIST. Geralmente, este estimativa está correta. Mas em nosso caso, o
operador && tem que buscar cada geometria do disco para comparar os saltos de caixa,
assim lendo todas as páginas TOAST, também.
Veja se a permissão deste erro, use o comando "EXPLAIN ANALYZE" do postgresql. Para
mais informação e os detalhes técnicos, você pode ler a linha na lista de envio de
desempenho do postgres: http://archives.postgresql.org/pgsql-performance/2005-02/
msg00030.php
5.1.2. Envolvimento com o trabalho
Equipes de PostgreSQL estão tentando resolver esta edição fazendo o estimativa de

"queries" TOAST-aware. Agora, estão aqui duas questões a respeito deste trabalho:
O primeiro a cerca deste trabalho deve forçar o operador da "query" a usar o índice. Emita
"SET enable_seqscan TO off;" ao usuário antes de emitir a "query". Isto força
basicamente o operador da "query" a evitar varreduras seqüenciais sempre que possível.
Assim usa o índice de GIST como usual. Mas este "flag" tem que ser ajustado em cada
conexão, e faz com que o operador da "query" faça estimações em outros casos, assim
que você se "SET enable_seqscan TO on;" depois da "query".
O segundo a cerca deste trabalho deve fazer a varredura seqüencial tão rápida como o
operador da "query" pensa. Isto pode ser conseguido criando uma coluna adicional
"caches" ao bbox, e agrupar de encontro a este. Em nosso exemplo, os comandos estão
como:
SELECT addGeometryColumn('myschema','mytable','bbox','4326','GEOMETRY','2');
UPDATE mytable set bbox = Envelope(Force_2d(the_geom));

Agora altere sua "query" para usar o operador do && de encontro ao bbox em vez do
geom_column, como:
SELECT geom_column FROM mytable WHERE bbox && SetSrid('BOX3D(0 0,1

1)'::box3d,4326);
Naturalmente, se você mudar ou adicionar linhas na tabela, você tem que manter o bbox
"in sync". A maneira mais transparente de fazer isto seria "triggers", mas você também
pode modificar sua aplicação para manter a coluna do bbox atual ou rodar uma "query"
do UPDATE acima depois de cada modificação.
5.2. CLUSTERing em índices da geometria
Para as tabelas que são na maior parte "read-only", e onde um único índice é usado para
a maioria das "queries", PostgreSQL oferece o comando "CLUSTER". Este comando
requisita novamente fisicamente todas as linhas de dados na mesma ordem que os
critérios do índice, rendendo duas vantagens do desempenho: porque a escala do índice
faz a varredura, o número das buscas na tabela dos dados é reduzido drasticamente. Em
segundo, se seu "set" de funcionamento concentrar-se a alguns intervalos pequenos nos
índices, você tem "caching" mais eficiente porque as linhas de dados são espalhadas ao
longo de poucas páginas dos dados. (procure ler a documentação do comando
"CLUSTER" do manual de PostgreSQL.)
Entretanto, atualmente PostgreSQL não permite "clustering" em índices PostGIS GIST

porque os índices de GIST simplesmente ignoram valores NULL, você obtem uma
mensagem de erro como:
lwgeom=# CLUSTER my_geom_index ON my_table;

ERROR: cannot cluster when index access method does not handle null values
HINT: You may be able to work around this by marking column "the_geom" NOT NULL.
Porque a mensagem HINT diz, uma pode trabalhar em torno desta deficiência
adicionando um constraint "not null" à tabela:
lwgeom=# ALTER TABLE my_table ALTER COLUMN the_geom SET not null;
ALTER TABLE
Naturalmente, isto não trabalhará se você de fato precisar de valores NULL em sua
coluna geométrica. Adicionalmente, você deve usar o método acima para adicionar o
"constraint", usando um CHECK "constraint" como "ALTER TABLE blubb ADD CHECK
(geometria não é null);" não trabalhará.
5.3. Evitando a conversão da dimensão
Às vezes,acontece de ter os dados 3D ou 4D em sua tabela, mas sempre acessa-a

usando as funções asText() ou asBinary() de OpenGIS que só sai geometrias 2D. Fazem
isto internamente chamando a função force_2d(), que introduz um "overhead" significante
para geometrias grandes. Para evitar estas "overhead", pode ser praticado "pre-drop"
naquelas dimensões adicionais uma vez e para sempre:
UPDATE mytable SET the_geom = force_2d(the_geom);

VACUUM FULL ANALYZE mytable;
Note que se adicionar sua coluna geometrica usando AddGeometryColumn() terá um
"constraint" na dimensão da geometria. Para contorná-la necessitará deixar cair o
"constraint". Recorde que para atualizar a entrada na tabela geometry_columns e recriar
mais tarde o "constraint".
No caso de tabelas grandes, pode ser dividido este UPDATE em porções confinando o
UPDATE a uma parte da tabela através da cláusula WHERE e sua chave primária ou uns
outros critérios praticáveis, e rodar um simples "VACUUM;" entre seus UPDATEs. Isto
reduz drasticamente a necessidade para o espaço em disco provisório. Adicionalmente,
se misturar dimensões geométricas, restringindo o UPDATE por "WHERE
dimension(the_geom)>2" pula reescrever da geometria que já estão no 2D.
Capítulo 6. Referências PostGIS

As funções descritas abaixo são as quais o usuário de PostGIS utiliza. Existem outras
funções que são requeridas como suporte de funções aos objetos de PostGIS que não
são de uso para um usuário comum.
6.1. Funções de OpenGIS
AddGeometryColumn(varchar, varchar, varchar, integer, varchar, integer)

Sintaxe: AddGeometryColumn(<schema_name>, <table_name>, <column_name>, <srid>,
<type>, <dimension>). Acrescenta uma coluna geométrica a uma tabela existente de
atributos. O dbname é o nome do exemplo de banco de dados. O srid devem ser uma
referência de valor inteiro a uma entrada dentro da tabela SPATIAL_REF_SYS. O tipo
deve ser uma string maiúscula que corresponde ao tipo de geometria , eg, ' POLÍGONO'
ou ' MULTILINESTRING '.
DropGeometryColumn(varchar, varchar, varchar)

Sintaxe: DropGeometryColumn(<schema_name>, <table_name>, <column_name>).
Remove uma coluna geométrica de uma tabela espacial. Note que o schema_name
necessitará combinar o campo do f_schema_name da linha da tabela na tabela dos
geometry_columns.
SetSRID(geometry)
Atribui o SRID em uma geometria para um valor de inteiro particular. É utilizado na
construção de caixas de salto para "queries".
6.1.2. Funções de Relacionamento da Geometria
Distance(geometry,geometry)
Retorna a distancia cartesiana entre duas geometrias em unidades projetadas.
Equals(geometry,geometry)
Retorna1 (VERDADEIRO) se esta geometria é que "spatially equal" (espacialmente
iguais) a uma outra geometria. Use ' = ' para uma melhor resposta .
equals (' LINESTRING(0 0, 10 10) ', ' LINESTRING(0 0, 5 5, 10 10) ') é verdade.
Executado pelo módulo de GEOS
OGC SPECs2.1.1.2
Disjoint(geometry,geometry)
Retorna 1 (VERDADEIRO) se esta Geometria é que "spatially disjoint" (desloca
espacialmente) de outra geometria.
Não chame "GeometryCollection" como um argumento
NOTA: esta é a versão "allowable" (permissível) que retorna uma boolean (condição
verdadeira ou falsa), e não um inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - a.Relate(b, ' FF*FF * * * * ')
Intersects(geometry,geometry)
Retorna 1 (VERDADEIRO) se esta geometria "spatially intersects" (cruza espacialmente)
outra geometria.
Não chame GeometryCollection como um argumento
OGC SPEC s2.1.1.2 / / s2.1.13.3 - Intersects(g1, g2)-Not (Disjoint(g1, g2))
Touches(geometry,geometry)
Retorna 1 (VERDADEIRO) se esta geometria "spatially touches" (toca espacialmente) de
outra geometria.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - a.Touches(b) - (I(a) intersection I(b) = {empty set}) e (a
intersection b) não vazio
Crosses(geometry,geometry)
Retorna 1 (VERDADEIRO) se esta geometria "spatially crosses" de outras geometrias.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - a.Relate(b, ' T*T * * * * * * ')
Within(geometry A,geometry B)
Retorna 1 (VERDADEIRO) se a geometria A é "spatially within" a geometria B.
NOTA: esta é a versão "allowable" (permissível) que retorna uma boolean, e não um
inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - a.Relate(b, ' T*F**F * * * ')
Overlaps(geometry,geometry)
Retorna 1 (VERDADEIRO) se Geometria é "spatially overlaps" (sobrepõe espacialmente).
inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3
Contains(geometry A, geometry B)
Retorna 1 (VERDADEIRO) se a geometria A "spatially contains" (contem espacialmente) a
geometria B.
inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - mesmo como within(geometry,geometry)
Intersects(geometry,geometry)
Retorna 1 (VERDADEIRO) se a geometria é "spatially intersects".
inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - NOT disjoint(geometry,geometry)
Relate(geometry,geometry, intersectionPatternMatrix)
Retorna 1 (VERDADEIRO) se esta geometria é espacialmente relatada para outra
geometria, testando interesecção entre o interior, o limite e o exterior de duas geometrias
como especificado pelos valores em umaintersectionPatternMatrix.
inteiro.
OGC SPEC s2.1.1.2 / / s2.1.13.3 - NOT disjoint(geometry,geometry)
Relate(geometry,geometry)
Retorna o DE-9IM (dimensionally extended nine-intersection matrix)
Não em especificação OGC, mas sub-entendido. veja s2.1.13.2
6.1.3. Funções de Processamento da Geometria
Centroid(geometry)
Retorna o identificador de centro da geometria como um ponto.
Computação será mais precisa que se executado pelo módulo de GEOS (ocorreu em
tempo de compilação).
Area(geometry)
Retorna a área da geometria, se é um polígono ou multi-polígono.
Length(geometry)
O comprimento desta curva em sua referência espacial associada.
sinônimo para length2d ()
OGC SPEC 2.1.5.1
PointOnSurface(geometry)
Retorna um ponto garantido estar na superfície
Implementado usando GEOS
OGC SPEC 3.2.14.2 e 3.2.18.2 -
Boundary(geometry)
Retorna o fechamento do limite combinatorial desta geometria. O limite combinatorial é
definido como descrito na seção 3.12.3.2 da OGC SPEC. Porque o resultado desta
função é um fechamento, e conseqüentemente fecharam topologicamente, o limite
resultante pode ser representado usando representação de primitivas geométricas como
discutido na OGC SPEC, seção 3.12.2.
OGC SPEC s2.1.1.1
Buffer(geometry,double,[integer])
Retorna uma geometria que represente todos os pontos que distanciam desta geometria
é menor ou igual a distancia. Cálculos estão em um Spacial Reference System desta
geometria. O terceiro parametro opcional atribui o número de segmentos usados para
aproximar um quarto de círculo (padrão para 8).
OGC SPEC s2.1.1.3
ConvexHull(geometry)
Retorna uma geometria que representa a casca convexa desta geometria.
OGC SPECs2.1.1.3
Intersection(geometry,geometry)
Retorna uma geometria que representa a interseção atribuída do ponto das Geometrias.
OGC SPEC s2.1.1.3
SymDifference(geometry A, geometry B)
Retorna uma geometria que representa a diferença simétrica atribuída do ponto da
geometria A com geometria B.
OGC SPEC s2.1.1.3
Difference(geometry A, geometry B)
Retorna uma geometria que representa a diferença atribuída do ponto da geometria A
com geometria B.
OGC SPEC s2.1.1.3
GeomUnion(geometry,geometry)
Retorna uma geometria que representa a união atribuída do ponto das geometrias.
NOTA: este é renomeado de "union" porque união é uma palavra reservada SQL
OGC SPEC s2.1.1.3
GeomUnion(geometry set)
Retorna uma geometria que representa a união atribuída do ponto de todas as geometrias
em dado conjunto.
Não chame GeometryCollection no conjunto de argumento
Nada definido em OGC SPEC
MemGeomUnion(geometry set)
Mesmo que o anterior, só que com "memory-friendly" (memória-amigável - usa menos
memória e mais tempo de processamento)
6.1.4. Assessores Geométricos
AsText(geometry)
Retorna a representação de Well-Known Text (WKT) da geometria. Por exemplo:
POLYGON(0 0,0 1,1 1,1 0,0 0)
OGC SPEC s2.1.1.1
AsBinary(geometry)
Retorna a geometria no OGC formato "well-known-bynary", usando a codificação endian
do usuário em que o banco de dados está funcionando. É utilizado em cursores binários
para extrair dados do banco de dados sem convertê-la a uma representação string.
OGC SPEC s2.1.1.1 - also see asBinary(<geometry>,'XDR') and
asBinary(<geometry>,'NDR')
SRID(geometry)
Retornos de números inteiros SRID do sistema de referência espacial da geometria.
OGC SPEC s2.1.1.1
Dimension(geometry)
A dimensão inerente deste objeto de geometria, que deve ser menor ou igual à dimensão
coordenada. OGC SPEC s2.1.1.1 - retorna 0 para pontos, 1 para linhas, 2 para polígonos,
e a maior dimensão dos componentes de um GEOMETRYCOLLECTION.
select dimension('GEOMETRYCOLLECTION(LINESTRING(1 1,0 0),POINT(0 0)');

dimension
-----------
1
Envelope(geometry)
Retorna um polígono representando a caixa delimitada da geometria.
OGC SPEC s2.1.1.1 - A caixa delimitada mínima para esta geometria, retornou como uma
geometria. O polígono está definido por pontos de curva da caixa delimitada ((MINX,
MINY), (MAXX, MINY), (MAXX, MAXY), (MINX, MAXY), (MINX, MINY)).
NOTA:PostGIS acrescentará uma coordenada de Zmin/Zmax também.
IsEmpty(geometry)
Retorna 1 (VERDADEIRO) se esta geometria é a geometria vazia. Se for verdade, então
esta geometria representa o conjunto de ponto vazio-i.e.GEOMETRYCOLLECTION
(EMPTY).
OGC SPEC s2.1.1.1
IsSimple(geometry)
Retorna 1 (VERDADEIRO) se esta geometria não tem nenhum ponto geométrico
anômalo, como intersecção própria ou tangência própria.
OGC SPECs2.1.1.1
IsClosed(geometry)
Retornos verdadeiros do começo de geometria e pontos finais são coincidentes.
IsRing(geometry)
Retorna 1 (VERDADEIRO) se esta Curva está fechada (StartPoint () = EndPoint ()) e esta
Curva é simples (não atravesse o mesmo ponto mais de uma vez).
Executado por GEOS
OGC spec 2.1.5.1
NumGeometries(geometry)
Se geometria é um GEOMETRYCOLLECTION (ou MULTI *) retorna o número de
geometrias. Caso contrário, retorna NULO.
GeometryN(geometry,int)
Retorna a enésima geometria se a geometria é uma GEOMETRYCOLLECTION,
MULTIPOINT, MULTILINESTRING ou MULTIPOLYGON. Caso contrário, retorna NULO.
Nota
Indice é 1-based como para especificações OGC desde a versão 0.8.0. As versões
anteriores executaram esta como 0-based preferivelmente.
NumPoints(geometry)
Encontra e Retorna o número de pontos na primeira linha na geometria. Retorna NULO se
não há nenhuma linha na geometria.
PointN(geometry,integer)
Retorna o enésimo ponto na primeira linha na geometria. Retorna NULO se não há
nenhuma linha na geometria.
ExteriorRing(geometry)
Retorna o anel exterior do primeiro polígono na geometria. Retorna NULO se não há
nenhum polígono na geometria.
NumInteriorRings(geometry)
Retorna o número de anéis interiores do primeiro polígono na geometria. Retorna NULO
se não há nenhum polígono na geometria.
NumInteriorRing(geometry)
Sinomimo para NumInteriorRings (geometry). As especificações OpenGIS são
ambiguas sobre o nome da função exata, assim que fornecemos ambas as
escritas.
InteriorRingN(geometry, integer)
Retorna o enésimo anel interior do polígono na geometria. Retorna NULO se não há
nenhum polígono na geometria ou o N dado é fora da escala(1 baseado).
Nota
Indice is 1-based como especificações para OGC desde a versão 0.8.0. As versões
anteriores implementaram esta como 0-based preferivelmente.
EndPoint(geometry)
Retorna o último ponto da geometria de "LineString" como um ponto.
StartPoint(geometry)
Retorna o primeiro ponto da geometria de "LineString" como um ponto.
GeometryType(geometry)
Retorna o tipo da geometria como uma string. Eg: ' LINESTRING ', ' POLYGON ', '
MULTIPOINT ', etc.
OGC SPEC s2.1.1.1 - Retorna o nome do sub-tipo imediato de geometria de qual neste
caso de geometria é um membro. O nome do sub-tipo imediato de geometria é devolvido
como uma string.
X(geometry)
Encontra e retorna a coordenada de X do primeiro ponto na geometria. Retorna NULO se
não há nenhum ponto na geometria.
Y(geometry)
Encontra e retorna a coordenada de Y do primeiro ponto na geometria. Retorna NULO se
Z(geometry)
Encontra e retorna a coordenada de Z do primeiro ponto na geometria. Retorna NULO se
M(geometry)
Retorna uma coordenada M do ponto, ou NULO se não disponível. A entrada deve ser um
ponto.
Nota
This is not (yet) part of the OGC spec, but is listed here to complete the point coordinate
extractor function list.
Esta não é (ainda) parte das especificações de OGC, mas é listada aqui
para completar a lista da função do extrator da coordenada do ponto.
GeomFromText(text,[<srid>])
Converte uma geometria de WKT com o dado SRID.
OGC SPEC 3.2.6.2 - a opção SRID está de conformidade.
PointFromText(text,[<srid>])
Faz uma geometria de WKT com o dado SRID. Caso SRID não der, padroniza-se -1.
OGC SPEC 3.2.6.2 - opção SRID está de conformidade.
Mostra um erro se o WKT não é um Ponto
LineFromText(text,[<srid>])
Mostra um erro se o WKT não é uma Linha
LinestringFromText(text,[<srid>])
Mostra um erro se o WKT não é uma Linha
PolyFromText(text,[<srid>])
Faz uma Geometria de WKT com o SRID dado . Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um Polígono
PolygonFromText(text,[<srid>])
Faz uma geometria de WKT com o SRID dado. Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um Polígono
MPointFromText(text,[<srid>])
Mostra um erro se o WKT não é um MULTIPOINT
MLineFromText(text,[<srid>])
Mostra um erro se o WKT não é um MULTILINESTRING
MPolyFromText(text,[<srid>])
Faz uma Geometria de WKT com o SRID dado. Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um MULTIPOLYGON
GeomCollFromText(text,[<srid>])
Mostra um erro se o WKT não é um GEOMETRYCOLLECTION
GeomFromWKB(bytea,[<srid>])
Faz uma geometria de WKB com o SRID dado. Caso SRID não der,
padroniza-se -1.
GeometryFromWKB(bytea,[<srid>])
padroniza-se -1.
PointFromWKB(bytea,[<srid>])
padroniza-se -1.
Mostra um erro se o WKT não é um PONTO
LineFromWKB(bytea,[<srid>])
Faz uma geometria de WKB com o SRID dado. Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um LINESTRING
LinestringFromWKB(bytea,[<srid>])
Mostra um erro se o WKT não é um LINESTRING
PolyFromWKB(bytea,[<srid>])
Mostra um erro se o WKT não é um POLÍGONO
PolygonFromWKB(bytea,[<srid>])
MPointFromWKB(bytea,[<srid>])
Mostra um erro se o WKT não é um MULTIPOINT
MLineFromWKB(bytea,[<srid>])
Mostra um erro se o WKT não é um MULTILINESTRING
MPolyFromWKB(bytea,[<srid>])
Faz uma Geometria de WKB com o SRID dado. Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um MULTIPOLYGON
GeomCollFromWKB(bytea,[<srid>])
Faz uma Geometria de WKB com o SRID dado. Caso SRID não der, padroniza-se -1.
Mostra um erro se o WKT não é um GEOMETRYCOLLECTION
BdPolyFromText(text WKT, integer SRID)

Construir um Polygon dada uma coleção arbitrária de linhas fechadas como uma
representação do texto MultiLineString. Lança um erro se WKT não for um
MULTILINESTRING. Lança um erro se a saída for um MULTIPOLYGON;
usa BdMPolyFromText neste caso ou vê BuildArea() para um acesso específico de
postgis.
OGC SFSQL 1.1 - 3.2.6.2
Disponibilidade: 1.1.0 - requer GEOS >= 2.1.0.
BdMPolyFromText(text WKT, integer SRID)

Construir um MultiPolygon dada uma coleção arbitrária de linha fechada como uma
respresentação do texto de MultiLineString. Lança um erro se WKT não for um
MULTILINESTRING. Força saída MULTIPOLYGON mesmo quando o resultado é
composto somente por um único POLYGON; usa BdPolyFromText se você estiver certo
que um único POLYGON resultará da operação ou veja BuildArea() para um acesso
específico de postgis.
OGC SFSQL 1.1 - 3.2.6.2
6.2. Extensões de Postgis
DropGeometryTable([<schema_name>], <table_name>)
Destrói uma tabela e todas suas referências nas colunas geométricas. Nota: usa
o current_schema() em instalações do pgsql schema-aware se o schema não for
fornecido.
UpdateGeometrySRID([<schema_name>], <table_name>, <column_name>, <srid>)

Atualiza o SRID de todas as características em uma coluna da geometria que atualiza
confinamente e referência nas colunas geométricas. Nota: usa o current_schema() em
instalações do pgsql schema-aware se o schema não for fornecido.
update_geometry_stats([<table_name>, <column_name>])
Atualiza estatisticas sobre tabelas espaciais para o uso pelo operador da seleção.
Precisará também rodar o "VACUUM ANALYZE [ table_name ] [ column_name ]" para as
estatisticas que recolhem o processo para estar completo. Nota: começando com
PostgreSQL 8.0 que analisando estatisticas é automaticamente executado rodando
"VACUUM ANALYZE".
postgis_version()
Retorna o número de versão de PostGIS e opções de tempo de compilação. Nota: Antes
da versão 1.1.0 esta era uma função procedural, assim possivelmente não estará
retornando a informação exata (em caso dos melhoramentos incompletos do banco de
dados).
postgis_lib_version()
Retorna o número de versão da biblioteca de PostGIS.
Disponível: 0.9.0
postgis_lib_build_date()
Retorna data da construção da biblioteca PostGIS.
Disponível: 1.0.0RC1
postgis_script_build_date()
Retorna data da construção de scripts PostGIS.
postgis_scripts_installed()
Retorna a versão do script postgis instalado neste banco de dados. Nota: Se a saída
desta função não combinasse com a saída de postgis_scripts_released() provavelmente
faltou promover corretamente um banco de dados existente. Veja a seção Upgrading para
mais informações.
Disponibilidade: 0.9.0
postgis_scripts_released()
Retorna o número da versão do script de lwpostgis.sql liberado com o instalado na
biblioteca do postgis. Nota: Começar com versão 1.1.0 esta função, retorna o mesmo
valor do postgis_lib_version(). Conservar para a compatibilidade inversa.
Disponível: 0.9.0
postgis_geos_version()
Retorna o número da versão da biblioteca de GEOS ou NULO se o suporte a GEOS não
for permitida.
Disponível: 0.9.0
postgis_proj_version()
Retorna o número da versão da biblioteca PROJ4 ou NULo se o suporte a PROJ4 não for
permitida.
Disponível: 0.9.0
postgis_uses_stats()
Retorna verdadeiro se o uso do STATS for permitido,caso contrário retorna falso.
Disponível: 0.9.0
postgis_full_version()
Retorna a versão postgis completa e constrói informações de configuração.
Disponível: 0.9.0
6.2.2. Operadores
A &< B
O operador "&<" retorna verdadeiro se a caixa delimitada sobrepor o próprio A ou está à
esquerda da caixa delimitada do próprio B.
A &> B
O operador "&>" retorna verdadeiro se a caixa delimitada sobrepor o próprio A ou está à
direita da caixa delimitada do próprio B.
A << B
O operador "<<" retorna verdadeiro se a caixa delimitada for estritamente à esquerda da
caixa delimitada do próprio B.
A >> B
O operador ">>" retorna verdadeiro se o salto de caixa do próprio A for estritamente à
direita do salto de caixa do próprio B.
A &<| B
O operador "&<|" returna verdadeiro se a caixa delimitada do próprio A for abaixo da caixa
delimitada do próprio B.
A |&> B
O operador "|&>" returna verdadeiro se a caixa delimitada de A for acima da caixa
delimitada do próprio B.
A <<| B
O operador "<<|" retorna verdadeiro se a caixa delimitada de A for estritamente abaixo da
A |>> B
O operador "|>>" retorna verdadeiro se a caixa delimitada A for esttritamente acima da
A ~= B
O operador "~ = " é o operador "same as". Testa igualdade geométrica atual de duas
características. Assim, se A e B são de mesma característica, o operador retorna
verdadeiro.
A@B
O operador "@ " retorna verdadeiro se a caixa delimitada do próprio A estiver
completamente contido na caixa delimitada do próprio B.
A~B
O operador "~" retorna verdadeiro se a caixa delimitada estiver completamente contida na
A && B
O operador "&& " é o operador sobreposto. Se a caixa delimitada do prórpio A sobrepor a
caixa delimitada do próprio B, o operador retorna verdadeiro.
6.2.3. Funções de Medida
area2d(geometry)
Retorna a área da geometria, se é um polígono ou multi-polígono.
distance_sphere(point, point)
Retorna a distância linear nos medidores entre dois pontos de lat/lon. Usa uma terra e um
raio esféricos de 6370986 medidores. Mais rapidamente do que distance_spheroid(), mas
menos exato. Atualmente só se implementou para pontos.
distance_spheroid(point, point, spheroid)

Retorna a distância linear entre dois pontos latitude/longitude dando um esferóide
particular. Veja a explicação de esferóides dados para length_spheroid(). Atualmente só
se implementou para pontos.
length2d(geometry)
Retorna o comprimento 2-dimensional da geometria se é um linestring ou multi-linestring.
length3d(geometry)
Retorna o comprimento 3-dimensional da geometria se é um linestring ou multi-linestring.
length_spheroid(geometry,spheroid)
Calcula o comprimento de uma geometria em um ellipsoid. É utilizada se as coordenadas
da geometria está em latitude/longitude e um comprimento é desejado sem reprojecções
O ellipsoid é um tipo de banco de dados separado e pode ser construído como segue:
SPHEROID[<NAME>,<SEMI-MAJOR AXIS>,<INVERSE FLATTENING>]
Outra forma:
SPHEROID["GRS_1980",6378137,298.257222101]
Um exemplo de cálculo poderia ser:
SELECT length_spheroid( geometry_column, 'SPHEROID["GRS_1980",

6378137,298.257222101]' )
FROM geometry_table;
length3d_spheroid(geometry,spheroid)
Calcula o comprimento de uma geometria em um ellipsoid, pegando a elevação dentro da
conta. É exatamente igual a length_spheroid excluindo as coordenadas verticais
(expressado nas mesmas unidades como os spheroid axes) são usados para calcular a
soma de deslocamento da distância extra vertical.
distance(geometry, geometry)
Retorna a distância menor entre duas geometrias..
max_distance(linestring,linestring)
Retorna a distância maior entre duas linhas de string.
perimeter(geometry)
Retorna o perímetro da geometria, se é um polígono ou multi-polígono.
perimeter2d(geometry)
Retorna o perímetro 2-dimensional da geometria, se é um polígono ou multi-polígono.
perimeter3d(geometry)
Retorna o perímetro 3-dimensional da geometria, se é um polígono ou multi-polígono.
azimuth(geometry, geometry)
Retorna o azimuth do segmento definido pelo dado geometrias Point ou o NULO, se
os dois pontos forem coincidentes. O valor do retorno está nos radianos.
Disponibilidade: 1.1.0
6.2.4. Saídas Geométricas

AsBinary(geometry,{'NDR'|'XDR'})
Retorna a geometria no formato OGC "well-known-bynary", usando "little-endian" (NDR)
ou big-endian (XDR) . É utilizado em cursores binários para extrair dados do banco de
dados sem convertê-la a uma representação string.
AsEWKT(geometry)
Retorna uma Geometria em formato EWKT (como texto).
AsEWKB(geometry, {'NDR'|'XDR'})
Retorna uma geometria em formato EWKB (como o "bytea") usando outra codificação
"little-endian" (NDR) ou "big-endian".
AsSVG(geometry, [rel], [precision])

Retorna a geometria como um dado do trajeto de SVG. Usa 1 como segundo argumento e
tem o trajeto dos dados implementados nos termos de movimentos relativos, o default (ou
0) usa movimentos absolutos. O terceiro argumento pode ser usado para reduzir o
número máximo dos dígitos decimais usados na saída ("default" para 15). Pontos de
geometrias serão rendidos como cx/cy quando arg 'rel' é 0, x/y quando 'rel' é 1.
AsGML(geometry, [precision])
Retorna a geometria como um elemento GML. O segundo argumento pode ser usado
para reduzir o número máximo dos dígitos significativos usados na saída (defaults para
15).
AsKML(geometry, [precision])
Retorna a geometria como um elemento KML. O segundo argumento pode ser usado
para reduzir o número máximo de dígitos significativos usados na saída ( defaults para
15).
GeomFromEWKT(text)
Faz a geometria de EWKT.
GeomFromEWKB(bytea)
Faz a geometria de EWKB.
MakePoint(<x>, <y>, [<z>], [<m>])

Cria um ponto 2d,3dz or 4d geométrico.
MakePointM(<x>, <y>, <m>)

Cria um ponto 3dm geométrico.
MakeBox2D(<LL>, <UR>)
Cria um BOX2D definido dados os pontos geométricos.
MakeBox3D(<LLB>, <URT>)
Cria um BOX3D definido dados os pontos geométricos.
MakeLine(geometry set)
Cria um Linestring de um conjunto de pontos de geometrias. Poderá usar um subselect
para ordenar os pontos antes de alimentá-los a este agregado.
MakeLine(geometry, geometry)
Cria um Linestring dados dois pontos geométricos.
LineFromMultiPoint(multipoint)
Cria um LineString de uma geometria MultiPoint.
MakePolygon(linestring, [linestring[]])
Cria um polígono formado pela proteção dada e pelo conjunto de regras. Poderá construir
um conjunto de geometria usando Accum. Entradas geométricas devem ser
LINESTRINGS fechadas (veja IsClosed e GeometryType).
BuildArea(geometry)
Cria uma geometria areal formada pelo componente de linha de trabalho da
geometria dada. O tipo do retorno pode ser um Polygon ou um MultiPolygon,
dependendo da entrada. Se a entrada das linhas de trabalho não forem forma de
polígonos, NULO é retornado. Veja também BdPolyFromText
e BdMPolyFromText - envoltórios para esta função com padrão de interface OGC.
Polygonize(geometry set)
Agregado. Cria um GeometryCollection que contem os polígonos possíveis formados de
componentes de linhas de trabalho de um conjunto de geometrias.
Disponível 1.0.0RC1 - requer GEOS >= 2.1.0.
Collect(geometry set)
Esta função retorna um GEOMETRYCOLLECTION ou um objeto MULTI de um conjunto
de geometrias. A função collect() é uma função "agregada" na terminologia de
PostgreSQL. Isso significa que operadores em listas de dados, na mesma maneira de
funções de sum() e de mean(). Para o exemplo, "SELECT COLLECT(GEOM) FROM
GEOMTABLE GROUP BY ATTRCOLUMN" retornará um GEOMETRYCOLLECTION
separado para cada valor distinto de ATTRCOLUMN.
Collect(geometry, geometry)
Esta função retorna uma geometria, sendo uma coleção de duas saídas geométricas. O
tipo de saída pode ser um MULTI* ou um GEOMETRYCOLLECTION.
Dump(geometry)
Esta é uma função de um conjunto de retornos (set-returning function-SRF). Retorna um
conjunto de linhas geometry_dump, formada por uma geometria (geom) e por um
conjunto de inteiros (path). Quando a entrada geometrica é um tipo simples
(POINT,LINESTRING,POLYGON) um único registro será retornado com um conjunto de
caminhos vazios e a entrada geométrica como geom. Quando a entrada geométrica é
uma coleção ou multi retornará um registro para cada um dos componentes da coleção, e
o caminho expressará a posição do componente dentro da coleção.
Disponibilidade: PostGIS 1.0.0RC1. Requer PostgreSQL 7.3 ou superiores.

DumpRings(geometry)
Esta é uma função de um conjunto de retornos (set-returning function-SRF). Retorna um
conjunto de linhas geometry_dump, formado por uma geometria (geom) e por uma
conjunto de inteiros (path). O campo “path” carrega o índice do anel do polígono, contem
um único elemento: 0 para o escudo, número do furo para regras. O campo do “geom”
contem o anel correspondente como um polígono.
Disponibilidade: PostGIS 1.1.3. Requer PostgreSQL 7.3 ou superiores.
6.2.6. Editores Geométricos
AddBBOX(geometry)
Adiciona caixa delimitada à geometria. Isto fará na caixa delimitada baseada em seleções
mais rápidas, mas aumentará o tamanho da geometria.
DropBBOX(geometry)
Destrói a caixa delimitada da geometria. Isto reduz o tamanho da geometria, mas as caixa
delimitada baseada em seleções mais lentas.
AddPoint(linestring, point, [<position>])

Adiciona um ponto a um LineString na posição <pos> (índice 0-based). O terceiro
parâmetro pode ser omitido ou ajustado a -1.
RemovePoint(linestring, offset)
Remove ponto de uma linestring. Offset é 0-based.
Disponível: 1.1.0
SetPoint(linestring, N, point)
Replace point N of linestring with given point. Index is 0-based.
Substitue o ponto N de linestring com o ponto dado. O índice é 0-based.
Disponível: 1.1.0
Force_collection(geometry)
Converte a geometria em um GEOMETRYCOLLECTION. É utilizado para simplificar a
respresentação de WKB.
Force_2d(geometry)
Força as geometrias dentro de um "2-dimensional mode" (modo bi-dimensional) de forma
que todas as representações de saída só terão as coordenadas X e Y. É utilizado para
forçar a saída OGC-compliant (desde que OGC especifica somente geometrias 2-D).
Force_3dz(geometry), Force_3d(geometry)
Força as geometrias dentro de um modo XYZ.
Force_3dm(geometry)
Força as geometrias dentro de um modo XYM.
Force_4d(geometry)
Força as geometrias dentro de um modo XYZM.
Multi(geometry)
Retorna a geometria como uma geometria MULTI*. Se a geometria já é uma MULTI*,
esta retornará inalterada.
Transform(geometry,integer)
Retorna uma nova geometria com suas coordenadas transformadas ao SRID referenciado
pelo parâmetro inteiro. O destino SRID tem que existir na tabela SPATIAL_REF_SYS.
Affine(geometry, float8, float8, float8, float8, float8, float8, float8, float8, float8, float8,
float8, float8)
Aplica uma trasformação 3d affine para a geometria. A chamada
Affine(geom, a, b, c, d, e, f, g, h, i,
xoff, yoff, zoff)
representa a matriz da transformação
/ a b c xoff \ | d e f
yoff | | g h i zoff | \ 0 0 0 1 /
e os vertices são transformados como segue:
x' = a*x + b*y + c*z + xoff y' = d*x +
e*y + f*z + yoff z' = g*x + h*y + i*z + zoff
Todas funções de tradução / escala abaixo são expressados através de

uma transformação affine.
Disponível: 1.1.2.
Affine(geometry, float8, float8, float8, float8, float8, float8)

Aplica uma transformação 2d affine para a geometria. A chamada
Affine(geom, a, b, d, e, xoff, yoff)
representa a matriz da transformação
/ a b 0 xoff \ / a b xoff \ | d e 0 yoff | rsp.

| d e yoff | | 0 0 1 0 | \ 0 0 1 / \ 0 0 0 1 /
e os vertices são transformados como segue:
x' = a*x + b*y + xoff y' = d*x + e*y +

yoff z' = z
Este método é um subcaso do método 3D acima.
Disponível: 1.1.2.
Translate(geometry,float8,float8,float8)
Traduz a geometria a um novo local que usa os parâmetros numéricos como recompensa.
Isto é: translate(geom,X,Y,Z).
Scale(geometry, float8, float8, float8)

Escala a geometria a um novo tamanho, multiplicando as ordenadas com os parâmetros.
Isto é: scale (geom, Xfactor, Yfactor, Zfactor).
Disponível: 1.1.0
RotateZ(geometry, float8), RotateX(geometry, float8), RotateY(geometry, float8),

Gira a geometria em torno da linha central de Z, X ou Y por dado ângulo dado nos
radianos. Seguir a regra right-hand.
Disponível: 1.1.2.
TransScale(geometry, float8, float8, float8, float8)

First, translates the geometry using the first two floats, then scales it using the second two
floats, working in 2D only. Using transscale(geom, X, Y, XFactor, YFactor) internally calls
affine(geom, XFactor, 0, 0, 0, YFactor, 0, 0, 0, 1, X*XFactor, Y*YFactor, 0).
Primeiro, traduz a geometria usando os primeiros dois floats, a seguir escala-o, usando os
segundos dois floats, trabalhando somente em 2D. Usando transscale(geom, X, Y,
XFactor, YFactor) internamente chama affine(geom, XFactor, 0, 0, 0, YFactor, 0, 0, 0, 1,
X*XFactor, Y*YFactor, 0).
Disponível: 1.1.0.
Reverse(geometry)
Retorna a geometria com a ordem do vértice invertida.
ForceRHR(geometry)
Força polígono da coleção a obedecer Right-Hand-Rule.
Simplify(geometry, tolerance)
Retorna uma versão "simplified" da geometria dada usando o algoritmo de Douglas-
Peuker. Desta forma, fará realmente algo com (multi)linhas e (multi)polígonos, mas você
pode estar seguro de chama-lo com qualquer tipo da geometria. Desde que a
simplificação ocorra em uma base "object-by-object" e você pode também alimentar um
GeometryCollection a esta função. Note que a geometria retornada pode perder sua
simplicidade. (veja IsSimple)
SnapToGrid(geometry, originX, originY, sizeX, sizeY), SnapToGrid(geometry, sizeX, sizeY),

SnapToGrid(geometry, size)
Pega todos os pontos de entrada da geometria à definição de grade por seu tamanho de
origem e de célula. Remove os pontos consecutivos que caem na mesma célula,
retornando eventualmente o NULO, se os pontos da saída não forem bastante para definir
uma geometria do tipo dado. As geometrias derrubadas em uma coleção são desfeitas
dela.
Nota
A geometria retornada pode perder sua simplicidade (veja IsSimple).
Nota
Antes da liberação 1.1.0 esta função retornou sempre uma geometria 2d .

Começando por 1.1.0 a geometria retornada terá mesmo
dimensionalidade que a entrada, uma com dimensão mais elevada valor não
tocado. Usar a versão pegando um segundo argumento de
geometria para definir todas as dimensões da grade.
SnapToGrid(geometry, geometry, sizeX, sizeY, sizeZ, sizeM)

Pega todos os pontos de entrada da geometria a definição de grade por seu tamanho de
origem (o segundo argumento, deve ser um ponto) e por seu tamanho de célula.
Especificar 0 como tamanho para alguma dimensão que você não quiser pegar para uma
grade.
Disponível: 1.1.0
Segmentize(geometry, maxlength)
Retorna uma geometria modificada que não tem nenhum segmento mais por muito tempo
então à distância dada. Os pontos interpolados terão os valores de Z e de M (se
necessário) ajustados a 0. A computação da distância é executada em somente em 2d.
LineMerge(geometry)
Retorna um (ou conjunto) LineString(s) formado por unindo a linha de trabalho (linework)
constituinte da entrada.
Disponível: 1.1.0 - requer GEOS >= 2.1.0
6.2.7. Referência Linear
line_interpolate_point(linestring, location)
Retorna um ponto interpolado ao longo de uma linha. O primeiro argumento deve ser um
LINESTRING. O segundo argumento é um float8 entre 0 e 1 representando fração do
total 2d length o ponto tem que ser encontrado.
Veja line_locate_point() para computar a posição da linha o mais próximo a um Point.
Nota
Desde a liberação 1.1.1 esta função tambem interpola valores M e Z (quando presente),
quando que as liberações anteriores ajustam-nas para 0.0.
Disponível: 0.8.2
line_substring(linestring, start, end)

Retorna um linestring sendo um substring da entrada uma que começa e que termina nas
frações do total 2d length. Os segundo e terceiro argumentos são os valores float8 entre 0
e 1.
Se o 'start' e 'end' tiverem o mesmo valor, este é equivalente ao line_interpolate_point().
Veja line_locate_point() para computar a posição da linha o mais próximo a um ponto.
Nota
Desde a liberação 1.1.1 esta função também interpola valores M e Z (quando

presente), quando que as liberações anteriores ajustam-nas aos valores não
especificados.
Disponível: 1.1.0
line_locate_point(LineString, Point)
Retorna um float entre 0 e 1 que representam a posição do ponto o mais próximo

em LineString para o dado Point, como uma fração do total
tamanho 2d line.
Você pode usar a posição retornada para extrair um Point (line_interpolate_point)
ou um substring (line_substring).
Disponível: 1.1.0
locate_along_measure(geometry, float8)
Retorna um valor derivado da coleção da geometria com elementos que combinam

a medida especificada. Os elementos Polygonal não são
suportados.
Semântica é especificado por: ISO/IEC CD 13249-3:200x(E) - Text for Continuation
CD Editing Meeting
Disponível: 1.1.0
locate_between_measures(geometry, float8, float8)

Retorna um valor derivado da coleção da geometria com elementos que combinam a
escala especificada das medidas inclusive. Os elementos Polygonal não são suportados.
Semântica é especificado por: ISO/IEC CD 13249-3:200x(E) - Text for Continuation CD
Editing Meeting
Disponível: 1.1.0
6.2.8. Variado
Summary(geometry)
Retorna um resumo de texto dos conteúdos da geometria.
box2d(geometry)
Retorna um BOX2D representando as extensões máximas da geometria.
box3d(geometry)
Retorna um BOX3D representando as extensões máximas da geometria.
extent(geometry set)
A função extent() é uma função "aggregate" (agregada) na terminologia de PostgreSQL.
Isso significa que os operadores em listas de dados, fazem o mesmo caminho que as
funções sum() e mean(). Por exemplo,
"SELECT EXTENT(GEOM) FROM GEOMTABLE" retornará um BOX3D dando a extensão
máxima de todas as características na tabela. Semelhantemente, "SELECT
EXTENT(GEOM) FROM GEOMTABLE GROUP BY CATEGORY" retornará um resultado
de extensão para cada categoria.
zmflag(geometry)
Returna ZM (semântica da dimensão) flag de geometrias como um inteiro.Valores são:
0=2d, 1=3dm, 2=3dz, 3=4d.
HasBBOX(geometry)
Retorna VERDADEIRO se o bbox desta geometria é armazenada, FALSO caso
contrário.Usa addBBOX() e dropBBOX() para armazenamento.
ndims(geometry)
Retorna o número das dimensões da geometria como um inteiro. Valores são: 2,3 ou 4.
nrings(geometry)
Se a geometria for um polígono ou um multi-polígono, retorna o número de anéis.
npoints(geometry)
Retorna o número de pontos na geometria.
isvalid(geometry)
Retorna verdadeiro se esta geometria for válida.
expand(geometry, float)
Esta função retorna uma caixa delimitada expandida em todos os sentidos da caixa
delimitada da entrada da geometria, por uma quantidade especificada no segundo
argumento. Muito usada para selecionar distance() , para adicionar um filtro do índice à
seleção.
estimated_extent([schema], table, geocolumn)

Retorna a extensão estimada da tabela espacial dada. O estimado é feito de estatisticas
de colunas geométricas. O "schema" atual será usado se não especificado.
Para estatística PostgreSQL>=8.0.0 são recolhidos por VACUUM ANALYZE e a extensão
resultante será aproximadamente 95% do real.
Para estatística PostgreSQL<8.0.0 são recolhidos por update_geometry_stats() e a
extensão resultante será exata.
find_srid(varchar,varchar,varchar)
A sintaxe é find_srid(<db/schema>, <tabela>, <coluna>) e a função retorna o inteiro SRID
da coluna especificada procurando através da tabela GEOMETRY_COLUMNS. Se a
coluna da geometria não for adicionada corretamente com a função de
AddGeometryColumns(), esta função não trabalhará tampouco.
mem_size(geometry)
Retorna a quantia de espaços (em bytes) encontrados na geometria.
numb_sub_objects(geometry)
Retorna o número dos objetos armazenados na geometria. Isto é utilizado para MULTI-
geometrias e GEOMETRYCOLLECTIONs.
point_inside_circle(geometry,float,float,float)
A sintaxe para esta função é point_inside_circle (<geometry>, <circle_center_x>,
<circle_center_y>, <radius>).
Retorna verdadeiro se a geometria é um ponto e está dentro do círculo. Caso contrário,
retorna falso.
xmin(box3d) ymin(box3d) zmin(box3d)

Retorna o mínimo solicitado de uma caixa delimitada.
xmax(box3d) ymax(box3d) zmax(box3d)

Retorna o máximo solicitado de uma caixa delimitada.
Accum(geometry set)
Agregado. Constrói um conjunto de geometrias.
6.2.9. Suporte a grandes transações (Long Transactions)
Este módulo e funções associadas de pl/pgsql foram implementados para fornecer

suporte a grandes bloqueios requerido por especificação Web Feature Service.
Nota
Os usuários devem usar serializable transaction level que caso contrário o mecanismo de
bloqueio quebraria.
EnableLongTransactions()
Permite suporte a transações grandes. Esta função cria as tabelas requeridas dos
metadados, necessita ser chamada uma vez antes de usar as outras funções nesta
seção. Chamá-la duas vezes é inofensivo.
Disponível: 1.1.3
DisableLongTransactions()
Desabilita suporte a transações grandes. Esta função remove as tabelas metadados de
suporte a transações grandes, e apaga todos os gatilhos às tabelas lock-checked.
Disponível: 1.1.3
CheckAuth([<schema>], <table>, <rowid_col>)

Verifica atualizações e deleções das linhas em dada tabela, sendo autorizada. Identifica
linhas usando a coluna <rowid_col>.
Disponível: 1.1.3
LockRow([<schema>], <table>, <rowid>, <authid>, [<expires>])

Ajuste de bloqueio/autorização para linha específica na tabela <authid> é um valor de
texto, <expires> é um timestamp padronizado para now() +1hour. Retorna 1 se o bloqueio
for assinado, 0 caso contrário (já bloqueado pelo outro auth)
Disponível: 1.1.3
UnlockRows(<authid>)
Remove todos os bloqueios carregados por id de autorização especificada. Retorna o
número dos bloqueios liberados.
Disponível: 1.1.3
AddAuth(<authid>)
Adiciona um símbolo da autorização a ser usado na transação atual.
Disponível: 1.1.3
6.3. Funções SQL-MM
Esta é uma listagem das funções definidas SQL-MM que PostGIS suporta atualmente. As
implementações destas funções seguem a implementação ArcSDE e assim desviar-se um
pouco das especificações. Estes desvios serão notados.
As of version 1.2.0, these functions have been implemented by wrapping existing PostGIS
functions. As a result, full support for curved geometries may not be in place for many
functions.
Até à data da versão 1.2.0, estas funções foram implementadas envolvendo funções
existentes no PostGIS. Em conseqüência, o suporte cheio para geometrias curvadas para
muitas funções não pode estar no lugar.
Nota
SQL-MM define o padrão SRID de todos construtores de geometrias como 0. PostGIS usa
um padrão SRID de -1.
ST_Area
Return the area measurement of an ST_Surface or ST_MultiSurface value.
Retorna a medida da área de um valor ST_Surface ou ST_MultiSurface.
SQL-MM 3: 8.1.2, 9.5.3
ST_AsBinary
Retorna a representação binária well-known de um valor ST_Geometry.
SQL-MM 3: 5.1.37
ST_AsText
Retorna a representação de texto well-known de um valor ST_Geometry.
SQL-MM 3: 5.1.25
ST_Boundary
Retorna o limite do valor ST_Geometry.
SQL-MM 3: 5.1.14
ST_Buffer
Retorna um buffer em torno do valor ST_Geometry.
SQL-MM 3: 5.1.17
ST_Centroid
Retorna centroid matemático do valor ST_Surface ou ST_MultiSurface.
SQL-MM 3: 8.1.4, 9.5.5
ST_Contains
Testa se um valor ST_Geometry espacialmente contem um outro valor ST_Geometry.
SQL-MM 3: 5.1.31
ST_ConvexHull
Retorna o hull convexo do valor ST_Geometry.
SQL-MM 3: 5.1.16
ST_CoordDim
Returna a dimensão da coordenada do valor ST_Geometry.
SQL-MM 3: 5.1.3
ST_Crosses
Testa se um valor ST_Geometry espacialmente atravessa outro valor ST_Geometry.
SQL-MM 3: 5.1.29
ST_Difference
Returna um valor ST_Geometry que representa a diferença do conjunto de pontos de dois
valores ST_Geometry.
SQL-MM 3: 5.1.20
ST_Dimension
Returna a dimensão do valor ST_Geometry.
SQL-MM 3: 5.1.2
ST_Disjoint
Testa se um valor ST_Geometry é espacialmente desconecta de outro valor
ST_Geometry.
SQL-MM 3: 5.1.26
ST_Distance
Returna a distancia entre duas geometrias.
SQL-MM 3: 5.1.23
ST_EndPoint
Returna um valor ST_Point que é o ponto final de um valor ST_Curve.
SQL-MM 3: 7.1.4
ST_Envelope
Returna o retângulo delimitado para o valor ST_Geometry.
SQL-MM 3: 5.1.15
ST_Equals
Testa se um valor ST_Geometry é espacialmente igual a outro valor ST_Geometry.
SQL-MM 3: 5.1.24
ST_ExteriorRing
Returna o anel exterior de um ST_Surface.
SQL-MM 3: 8.2.3, 8.3.3
ST_GeometryN
Returna a indicação do valor ST_Geometry de um ST_GeomCollection.
SQL-MM 3: 9.1.5
ST_GeometryType
Returna o tipo geométrico do valor ST_Geometry.
SQL-MM 3: 5.1.4
ST_GeomFromText
Returna uma especificação do valor ST_Geometry.
SQL-MM 3: 5.1.40
ST_GeomFromWKB
Returna uma especificação do valor ST_Geometry.
SQL-MM 3: 5.1.41
ST_InteriorRingN
Returna o anel interior especificado de um valor ST_Surface.
SQL-MM 3: 8.2.6, 8.3.5
ST_Intersection
Returna um valor ST_Geometry que representa a interseção do conjunto de pontos de
dois valores ST_Geometry.
SQL-MM 3: 5.1.18
ST_Intersects
Testa se um valor ST_Geometry intercepta espacialmente outro valor ST_Geometry.
SQL-MM 3: 5.1.27
ST_IsClosed
Testa se um valor ST_Curve ou um valor ST_MultiCurve está fechado.
Nota
SQL-MM define o resultado de ST_IsClosed(NULL) para ser 0, quando PostGIS returna

NULO.
SQL-MM 3: 7.1.5, 9.3.3
ST_IsEmpty
Testa se um valor ST_Geometry corresponde à um conjunto vazio.
Nota
SQL-MM define o resultado de ST_IsEmpty(NULL) para ser 0, quando PostGIS returna

NULO.
SQL-MM 3: 5.1.7
ST_IsRing
Testa se um valor ST_Curve é um anel.
Nota
SQL-MM define o resultado de ST_IsRing(NULL) para ser 0, quando PostGIS returna

NULO.
SQL-MM 3: 7.1.6
ST_IsSimple
Testa se um valor ST_Geometry não tem pontos geométricos anomalos, como própria
interseção ou própria tangência.
Nota
SQL-MM define o resultado de ST_IsSimple(NULL) para ser 0, qunado PostGIS returna

NULO.
SQL-MM 3: 5.1.8
ST_IsValid
Testa se um valor ST_Geometry está bem formado.
Nota
SQL-MM define o resultado de ST_IsValid(NULL) para ser 0, quando PostGIS returna

NULO.
QL-MM define o resultado de ST_IsValid(NULL) para ser 1.
SQL-MM 3: 5.1.9
ST_Length
Returna a medida do comprimento de um valor ST_Curve ou um valor ST_MultiCurve.
SQL-MM 3: 7.1.2, 9.3.4
ST_LineFromText
Returna uma especificação do valor ST_LineString.
SQL-MM 3: 7.2.8
ST_LineFromWKB
Returna uma especificação de valor ST_LineString.
SQL-MM 3: 7.2.9
ST_MLineFromText
Returna uma espeficiação de valor ST_MultiLineString.
SQL-MM 3: 9.4.4
ST_MLineFromWKB
Returna uma especificação de valor ST_MultiLineString.
SQL-MM 3: 9.4.5
ST_MPointFromText
Returna uma especificação de valor ST_MultiPoint.
SQL-MM 3: 9.2.4
ST_MPointFromWKB
Returna uma especificação de valor ST_MultiPoint.
SQL-MM 3: 9.2.5
ST_MPolyFromText
Returna uma especificação de valor ST_MultiPolygon.
SQL-MM 3: 9.6.4
ST_MPolyFromWKB
Returna uma especificação de valor ST_MultiPolygon.
SQL-MM 3: 9.6.5
ST_NumGeometries
Returna o número de geometrias em um ST_GeomCollection.
SQL-MM 3: 9.1.4
ST_NumInteriorRing
Returna o número de asnéis interiores em um ST_Surface.
SQL-MM 3: 8.2.5
ST_NumPoints
Returna o número de pontos em um valor ST_LineString ou um valor ST_CircularString.
SQL-MM 3: 7.2.4
ST_OrderingEquals
ST_OrderingEquals compara duas geometrias e t (TRUE) se as geometrias são iguais e
as coordenadas estão na mesma ordem; caso contrário retorna f (FALSE).
Nota
Esta implementação é feita como especificação ArcSDE SQL melhor que SQL-MM. http://
edndoc.esri.com/arcsde/9.1/sql_api/sqlapi3.htm#ST_OrderingEquals
SQL-MM 3: 5.1.43
ST_Overlaps
Testa se um valor ST_Geometry sobrepõe camadas espacialmente a outro valor
ST_Geometry.
SQL-MM 3: 5.1.32
ST_Perimeter
Returna a medida do comprimento do limite de um valor ST_Surface ou de um valor
ST_MultiRSurface.
SQL-MM 3: 8.1.3, 9.5.4
ST_Point
Returna um ST_Point com os valores de coordenadas dadas.
SQL-MM 3: 6.1.2
ST_PointFromText
Returna uma especificação de valor ST_Point.
SQL-MM 3: 6.1.8
ST_PointFromWKB
Returna uma especificação de valor ST_Point.
SQL-MM 3: 6.1.9
ST_PointN
Returna uma especificação de valor ST_Point em um ST_LineString ou ST_CircularString.
SQL-MM 3: 7.2.5, 7.3.5
ST_PointOnSurface
Returna um valor ST_Point garantido para interseção espacialmente do valor ST_Surface
ou ST_MultiSurface.
SQL-MM 3: 8.1.5, 9.5.6
ST_PolyFromText
Returna uma especificação de valor ST_Polygon.
SQL-MM 3: 8.3.6
ST_PolyFromWKB
Returna uma especificação de valor ST_Polygon.
SQL-MM 3: 8.3.7
ST_Polygon
Returna uma construção de polígono de uma linestring especificada e SRID.
SQL-MM 3: 8.3.2
ST_Relate
Testa se um valor ST_Geometry é relatado espacialmente à outro valor ST_Geometry.
SQL-MM 3: 5.1.25
ST_SRID
Returna o identificador de sistema de referência espacial do valor ST_Geometry.
SQL-MM 3: 5.1.5
ST_StartPoint
Returna um valor ST_Point que é o ponto inicial de um valor ST_Curve.
SQL-MM 3: 7.1.3
ST_SymDifference
Returna um valor ST_Geometry que representa a diferença simétrica de um conjunto de
pontos de dois valores ST_Geometry.
SQL-MM 3: 5.1.21
ST_Touches
Testa se um valor ST_Geometry tocado espacialmente por outro valor ST_Geometry.
SQL-MM 3: 5.1.28
ST_Transform
Returna um valor ST_Geometry transformado para sistema de referência espacial
especificado.
SQL-MM 3: 5.1.6
ST_Union
Returna um valor ST_Geometry que representa a união de um conjunto de pontos de dois
valores ST_Geometry.
SQL-MM 3: 5.1.19
ST_Within
Testa se um valor ST_Geometry é espacialmente dentro de outro valor ST_Geometry.
SQL-MM 3: 5.1.30
ST_WKBToSQL
Returna um valor ST_Geometry para uma dada representação binária well-known.
SQL-MM 3: 5.1.36
ST_WKTToSQL
Returna um valor ST_Geometry para uma dada representação de texto well-known.
SQL-MM 3: 5.1.34
ST_X
Returna o valor da coordenada x de um valor ST_Point.
SQL-MM 3: 6.1.3
ST_Y
Returna o valor da coordenada y de um valoST_Point.
SQL-MM 3: 6.1.4
6.4. Funções ArcSDE
As funções adicionais foram acrescidas para melhorar o suporte a uma interface de

estilo ArcSDE.
SE_EnvelopesIntersect
Returna t (TRUE) se os envelopes de duas interseções de geometrias; caso
contrário, returna f (FALSE).
SE_Is3d
Testa se um valor de geometria tem valores de coordenada z.
SE_IsMeasured
Testa se um valor de geometria tem valores de coordenada m.
SE_LocateAlong
Returna um valor de coleção de geometria derivada com elementos que combinam a
medida especificada.
SE_LocateBetween
Returna um valor de coleção de geometria derivada com elementos que combinam a
escala especificada das medidas inclusive.
SE_M
Returna o valor da coordenada m de um valor ST_Point.
SE_Z
Returna o valor da coordenada z de um valor ST_Point.
Capítulo 7. Relatando Erros
Relatar erros é uma maneira fundamental de ajudar no desenvolvimento de PostGIS. O

relatório mais eficaz de erro é aquele que permite desenvolvedores PostGIS reproduzi-lo,
assim conteria um script engatilhando-o e cada informação a respeito do ambiente em
que foi detectada. Uma boa e completa informação pode ser extraída rodando SELECT
postgis_full_version() [for postgis] e SELECT version() [for postgresql].
Se você não estiver usando a liberação anterior, vale a pena dar uma olhada primeiro no
release changelog, para verificar se seu erro já foi corrigido.
Usar o PostGIS bug tracker assegurará que seus relatórios não serão rejeitados, e
o manterá informado estando com um processo seguro. Antes de relatar um erro novo,
pesquise no banco de dados para ver se este erro já é conhecido, e se for adicione
toda informação nova que tiver sobre ele.
Você poderá ler o papel de Simon Tatham sobre How to Report Bugs Effectively
antes de arquivar um relatório novo.
Apendice A. Apendice
Índice
A.1.Notas de Versão
A.1.1. Versão 1.2.1
A.1.2. Versão 1.2.0
A.1.3. Versão 1.1.6
A.1.4. Versão 1.1.5
A.1.5. Versão 1.1.4
A.1.6. Versão 1.1.3
A.1.7. Versão 1.1.2
A.1.8. Versão 1.1.1
A.1.9. Versão 1.1.0
A.1.10. Versão 1.0.6
A.1.11. Versão 1.0.5
A.1.12. Versão 1.0.4
A.1.13. Versão 1.0.3
A.1.14. Versão 1.0.2
A.1.15. Versão 1.0.1
A.1.16. Versão 1.0.0
A.1.17. Versão 1.0.0RC6
A.1.18. Versão 1.0.0RC5
A.1.19. Versão 1.0.0RC4
A.1.20. Versão 1.0.0RC3
A.1.21. Versão 1.0.0RC2
A.1.22. Versão 1.0.0RC1
A.1. Notas da Versão
A.1.1. Versão 1.2.1
Data da versão: 11/01/2007

Esta versão fornece erro fixo no suporte PostgreSQL 8.2 e em alguns pequenos
aumentos de desempenho.
A.1.1.1. Mudanças
Fixado erro de atalho point-in-polygon em Within().

Fixado PostgreSQL 8.2 NULO na manipulação para índices.
Atualizados arquivos de especificação RPM.
Adicionado short-circuit para transform() dentro do case no-op.
JDBC: Fixado JTS manipulando para geometrias multi-dimensional (agradecimentos a

Thomas Marti pela sugestão e a colaboração parcial).
Adicionalmente, agora JavaDoc é compilado e empacotado. Fixados problemas do
classpath com GCJ. Fixados compatibilidade do pgjdbc 8.2, perdendo suporte para JDK
1.3 e anteriores.
A.1.2. Versão 1.2.0
Data da versão: 08/12/ 2006
Esta versão fornece definições de tipo junto com potencialidades da serialização/

deserialização para geometrias curvadas definidas SQL-MM, assim como aumentos de
desempenho.
A.1.2.1. Mudanças
Adicionado suporte ao tipo de geometria curvada para serialização/deserialização.

Adicionado um curto circuito point-in-polygon para as funções Contains e Within para
melhorar o desempenho para estes casos.
A.1.3. Versão 1.1.6
Esta é uma versão de fixação de erro, em particular que fixa um erro crítico com interface
GEOS nos sistemas 64bit. Inclui uma atualização dos parâmetros SRS e de uma
melhoria nas reprojeções (tome Z na consideração). Melhoria é incentivada.
A.1.3.1. Melhorias
Se você estiver promovendo da versão 1.0.3 ou posteriores siga este procedimento soft
upgrade.
Se você estiver promovendo de uma versão entre 1.0.0RC6 e 1.0.2 (inclusive) e querer
realmente um melhoramento vivo leia o upgrade section do capítulo notas da versão
1.0.3.
Melhorias de alguma versão anterior à 1.0.0RC6 requer um hard upgrade.
A.1.3.2. Correções
Fixada mudança CAPI que quebrou plataforma 64-bit.
carregador/descarregador: fixado testes de regressão e uso de saída.
Fixado erro setSRID() em JDBC, agradecimento à Thomas Marti.
A.1.3.3. Outras Mudanças
uso ordenada Z nas reprojeções.

spatial_ref_sys.sql alterado para EPSG 6.11.1 para uso de um pacote simples de
variáveis de versão para todos.
Inclue a Version.config no carregador/descarregador de mensagens USAGE.

Substitue o hand-made, analizador de versão JDBC frágil com Properties.
A.1.4. Versão 1.1.5
Esta é uma versão de correções, incluindo um padrão de segmento crítico no win32.

Melhorias são incentivadas.
A.1.4.1. Melhorias
Se quiser melhorias da versão 1.0.3 ou posteriores siga o procedimento soft upgrade.

Se quiser melhorias da versão entre 1.0.0RC6 e 1.0.2 (inclusive) e realmente quer uma
melhoria leia upgrade section do capítulo notas da versão 1.0.3.
Melhorias de alguma versão anterior para 1.0.0RC6 requer um hard upgrade.
Fixado erro de link MingW que foi causado pgsql2shp para segmento padrão em Win32
quando compilado por PostgreSQL 8.2.
fixado nullpointer Exception no método Geometry.equals() em Java.
Adicionado EJB3Spatial.odt para cumprir a exigência de distribuição GPL “preferred form
of modification”.
Removido sincronização obsoleta JDBC do código Jts.
Atualizado pesadamente os antiquados arquivos README para shp2pgsql/pgsql2shp
fundindo-o com as páginas principais.
Fixada etiqueta versão no código jdbc que ainda diz “1.1.3” na versão “1.1.4”.
A.1.4.3. Novas Características
Adicionada opção -S option para geometrias non-multi para shp2pgsql.
A.1.5. Versão 1.1.4

Esta é uma versão de fixação de erro incluindo algumas melhorias na interface Java.
Melhorias são incentivadas.
A.1.5.1. Melhorias

Se quiser melhorias de uma versão entre 1.0.0RC6 e 1.0.2 (inclusive) e realmente quer
uma melhoria leia o upgrade section do capítulo notas da versão 1.0.3.
Fixado suporte para PostgreSQL 8.2.
Fixado erro na função collect() descartando SRID de entrada.

Adicionado SRID que verifica a combinação em MakeBox2d e MakeBox3d.
Fixado regresso de testes para passar com GEOS-3.0.0.
Improved pgsql2shp run concurrency.
Melhorada a concorrência de execução pgsql2shp.
A.1.5.3. Mudanças Java
Retrabalhado o suporte JTS para refletir novos upstream atitudes de desenvolvedores

próprios JTS para manipulação do SRID. Simplifica o código e a apaga a construção que
depende de GNU Trove.
Adicionado o suporte EJB2 doado pela "Geodetix s.r.l. Company" http://www.geodetix.it/ .
Adicionado tutorial/exemplos EJB3 doados por Norman Barker <nbarker@ittvis.com>.
Reorganizado um pouco o leiaute do diretório java.
A.1.6. Versão 1.1.3
Data da versão: 30/062006
Esta é uma versão de fixação de erro incluindo também algumas funcionalidades novas
(mais notavelmente suporta a grandes transações) e aumento de portabilidade. Melhorias
são incentivadas.
A.1.6.1. Melhorias
Se quiser melhorias da versão 1.0.3 ou posteriores siga o procedimento soft upgrade.Se

quiser melhorias de uma versão entre 1.0.0RC6 e 1.0.2 (inclusive) e realmente quer uma
melhoria leia o upgrade section do capítulo notas da versão 1.0.3.
A.1.6.2. Correções/exatidão
CORREÇAO em distance(poly,poly) dando resultados errados.

CORREÇAO em pgsql2shp código de retorno bem sucedido.
CORREÇAO em shp2pgsql manipulando MultiLine WKT.
CORREÇAO em affine() falha na atualização da caixa delimitada.
WKT analisador: construção proibida das multigeometrias com elementos EMPTY
(suportados ainda para GEOMETRYCOLLECTION).
A.1.6.3. Novas Funcionalidades
NOVO suporte a grandes Transações.

NOVO função DumpRings().
NOVO função AsHEXEWKB(geom, XDR|NDR).
A.1.6.4. Mudanças JDBC
Testes de regressão melhorados: MultiPoint e ordenadas científicas.

Fixado alguns erros menores em código code.
Adicionada as funções acessor apropriado que funciona para todos os campos na
preparação de fazer aqueles campos privados mais tarde.
NOVO suporte de teste de regressão para carregador/descarregador.

Adicionado --with-proj-libdir e --with-geos-libdir para configurar interruptores (switches).
Suporte para contruir Tru64 build.
Usar Jade para gerar documentação.
Sem link pgsql2shp para mais libs então requerida.
Suporte inicial para PostgreSQL 8.2.
A.1.7. Versão 1.1.2
Esta é uma versão de fixação de erro incluindo algumas funções e novos aumentos de
portabilidade. Melhorias são incentivadas.
A.1.7.1. Melhorias

CORREÇAO em SnapToGrid() computação da saída da caixa delimitada.

CORREÇAO em EnforceRHR().
jdbc2 SRID manipulando reparos no código JTS.
Fixado suporte para arquitetura 64bit.

Testes de regressão agora podem ser executados *before* instalação postgis.
Novas funções de transformação de matriz affine().
Nova função rotate{,X,Y,Z}().
Antigas funções translating e scaling agora usam internamente affine().
Controle de acesso enfileirado estimated_extent() para construção com pgsql >= 8.0.0.
script ./configure mais portável.

Alterado o script ./run_test para ter um comportamento padrão mais sensato.
A.1.8. Versão 1.1.1
Esta é uma versão importante de correções, melhorias é altamente recomendada. A

versão precedente conteve um erro em postgis_restore.pl que impede o
procedimento hard upgrade de completar-se e um erro no conector GEOS-2.2+ que
impede os objetos GeometryCollection a serem usados em operações topológicas.
A.1.8.1. Melhorias
Se quiser melhorias da versão 1.0.3 ou posteriores siga o procedimento soft upgrade.Se

quiser melhorias de uma versão entre 1.0.0RC6 e 1.0.2 (inclusive) e realmente quer uma
melhoria leia o upgrade section do capítulo notas da versão 1.0.3.
Fixado uma saída prematura em postgis_restore.pl.

Fixação de erro no geometrycollection manipulando conector GEOS-CAPI.
Solaris 2.7 e melhorias de suporte MingW.
Fixação de erro no line_locate_point().
Fixado manipulação de caminho postgresql.
Fixação de erro no line_substring().
Adicionado suporte para conjunto localizado no verificador de regressão.
Nova interpolação Z e M no line_substring().

Nova interpolação Z e M no line_interpolate_point().
Adicionado NumInteriorRing() aliás devido a ambiguidade OpenGIS.
A.1.9. Versão 1.1.0
Esta é uma versão menor, contendo muitas melhorias e coisas novas. O mais notavel: o
procedimento da construção extremamente simplificada; transform() desempenho
melhorado drasticamente; mais estabilidade na conectividade GEOS (suporte CAPI);
muitas novas funções; suporte da topologia do esboço.
É altamente recomendado melhoria para antes de GEOS-2.2.x instalando PostGIS, isto
assegurará futuros melhoramentos GEOS não requererá uma reconstrução da biblioteca
de PostGIS.
A.1.9.1. Créditos
Esta versão inclui o código de Mark Cave Ayland para esconder objetos proj4. Markus
Schaber adicionou muitas melhorias em seu código JDBC2. Alex Bodnaru ajudou
com fonte PostgreSQL relevo da dependência e fornece especificação de
arquivos Debian. Michael Fuhr testou coisas novas na arquitetura Solaris. David Techer e
Gerald Fenoy ajudaram testar conector GEOS C-API. Hartmut Tschauner forneceu o
código para a função azimuth(). Devrim GUNDUZ forneceu especificação de
arquivos RPM. Carl Anderson ajudou com a nova área de construção das funções. Veja a
seção credits para consultar mais nomes.
A.1.9.2. Melhorias
Se quiser melhorias de uma versão 1.0.3 ou anterior NÃO precisa descarregar/recarregar.

Simplesmente o fonte trabalhará um novo roteiro lwpostgis_upgrade.sql em todos seus
bancos de dados existentes. Veja o capítulo soft upgrade para mais informação.
A.1.9.3. Novas Funções
métodos companheiros scale() e transscale() para translate().

line_substring().
line_locate_point().
M(point).
LineMerge(geometry).
shift_longitude(geometry).
azimuth(geometry).
locate_along_measure(geometry, float8).
locate_between_measures(geometry, float8, float8).
SnapToGrid by point offset (up to 4d support).
BuildArea(any_geometry).
OGC BdPolyFromText(linestring_wkt, srid).
OGC BdMPolyFromText(linestring_wkt, srid).
RemovePoint(linestring, offset).
ReplacePoint(linestring, offset, point).
Escape da memória fixado no polygonize().

Corrigidas funções cast lwgeom_as_anytype.
Fixados elementos USE_GEOS, USE_PROJ e USE_STATS da saída postgis_version()
para refletir sempre em estado de biblioteca.
A.1.9.5. Mudanças de Semântica de Função
SnapToGrid não rejeita dimensões mais elevadas.

Função changed Z() retorna NULO se a dimensão pedida não está disponível.
A.1.9.6. Melhorias de Desempenho
Muito mais rapida a função transform(), objetos escondidos proj4.

Chamada automática removida para fix_geometry_columns () em AddGeometryColumns
() e update_geometry_stats ().
A.1.9.7. JDBC2 works
Melhorias no Makefile.
Melhorias no suporte JTS.
Sistema de teste de regressão melhorado.
Método de verificação de consistência básica para coleções da geometria.
Suporte para (Hex)(E)wkb.
Auto investigação DriverWrapper para interruptores HexWKB / EWKT.
problemas para compilar fixo em ValueSetter para antigas versãos JDK.
Construtores EWKT fixos para aceitar representação SRID=4711;
Adicionada preliminar suporte read-only para geometrias java2d.
A.1.9.8. Outras Novas Funções
Configuração autoconf-based completa, com relevo da dependência da fonte

PostgreSQL.
Suporte GEOS C-API (2.2.0 e mais elevada).
Suporte inicial para modelagem de topologia.
Especificação de arquivos Debian e RPM.
Novo script lwpostgis_upgrade.sql.
Melhorias no suporte JTS.

Stricter mapping between DBF and SQL integer and string attributes
Mapeamento mais estrito entre o inteiro DBF e SQL e atributos de string.
Wider and cleaner regression test suite
Suite de teste de regressão mais largo e mais limpo.
Antigo código jdbc removido da Versão.
Obsoleto uso direto de postgis_proc_upgrade.pl.
Versão unificada de scripts com versão Versão.
A.1.10. Versão 1.0.6

Contem algumas correções e melhorias.
A.1.10.1. Melhorias

Fixada chamada palloc(0) na coleção deserializadora (só dá problema com --enable-

cassert).
Fixado cache bbox de manipulação de erros.
Fixada falha de segmento geom_accum(NULL, NULL).
Fixada falha de segmento em addPoint().
Fixado short-allocation em lwcollection_clone().
Fixado erro em segmentize().
Fixada computação bbox de saída SnapToGrid.
A.1.10.3. Improvements
Suporte inicial para postgresql 8.2.

Adicionado o faltante da má combinação SRID que verifica ops GEOS.
A.1.11. Versão 1.0.5
Contem memory-alignment fixa na biblioteca, uma falta de segmento fixo no seu

carregador manipulando atributos de UTF8 e algumas melhorias e limpezas.
Nota
Retorna código shp2pgsql alterado de Versãos anteriores para conformar-se aos padrões
unix (retorna 0 no sucesso).
A.1.11.1. Melhorias
Se quiser melhorias de uma versão 1.0.3 ou anterior NÃO precisa descarregar/

recarregar.Se quiser melhorias de uma versão entre 1.0.0RC6 e 1.0.2 (inclusive) e
realmente quer uma melhoria leia o upgrade section do capítulo notas da versão 1.0.3.
A.1.11.2. Mudanças de Bibliotecas
Fixada problemas de alinhamento de memória.
Fixada computação de fração de valores nulos no analisador.
Fixado um pequeno erro na função getPoint4d_p() low-level.
Velocidade alta das funções do serializador.
Fixado um erro em force_3dm(), force_3dz() e force_4d().
A.1.11.3. Mudanças de Carregador
Fixado return code de shp2pgsql.

Fixado título back-compatibility no carregador (carga de shapefiles nulos).
Fixado manipulação de pontos arrastando em atributos numéricos dbf.
Falha no segmento fixo em shp2pgsql (utf8 encoding).
A.1.11.4. Outras Mudança
Esquema postgis_proc_upgrade.pl ciente, suporte para pgsql 7.2+.

Novo capítulo no manual "Relatando Erros".
A.1.12. Versão 1.0.4
Contem correções importantes e algumas melhorias. Em particular, fixa um escape da

memória que impede a construção bem sucedida de índices GiST para tabelas espacial
grandes.
A.1.12.1. Melhorias

Escape de memória conectado na indexação GiST.
Falta de segmento fixo no transform() com manipulaçao de erros proj4.

Fixado alguns textos proj4 no spatial_ref_sys (perdido +proj).
Carregador: fixada uso da função string, retrabalhado verificação de objetos NULO, fixada
falta de segmento na entrada MULTILINESTRING.
Corrigidos em manipulação de dimensão do MakeLine.
Corrigidos em translate() corrupção de saída da caixa delimitada.
A.1.12.3. Melhorias
Melhorias na documentação.
Estimador de seletividade mais robusto.
Menor velocidade alta em distance().
Menor limpeza.
Limpeza em índices GiST.
Aceitação de sintaxe mais solto no analisador box3d.
A.1.13. Versão 1.0.3
Contem algumas correções - incluindo um severo afeição exata de geometries

armazenados - e algumas melhorias.
A.1.13.1. Melhorias
Devido a um erro em uma rotina computacional de caixa delimitada, a melhoria do

procedimento requer atenção especial, porque as caixas delimitadas armazenadas no
banco de dados poderiam estar incorretas.
Um procedimento (descarrega/recarrega) hard upgrade forçará a recomputação de todas
as caixas delimitadas (não incluídas nos descarregadores). Isto é requerido se melhorias
em Versãos anteriores à 1.0.0RC6.
Se você tiver melhorias das versões 1.0.0RC6 ou posteriores, esta Versão inclui um script
perl (utils/rebuild_bbox_caches.pl) para forçar a recomputação das caixas delimitadas de
suas geometrias e para invocar todas as operações requeridas propagar mudanças
eventuais nelas (atualização das estatisticas da geometria, reindexação). Invocar o script
depois de um make install (executar sem argumentos para ajuda da sintaxe).
Opcionalmente executar utils/postgis_proc_upgrade.pl para atualização de procedimentos
do postgis e assinaturas das funções (veja Soft upgrade).
Correção severa em lwgeom's 2d computação de caixa delimitada.

Correção no WKT (-w) POINT manipulando no carregador.
Correção no descarregador em máquinas 64bit.
Correção na manipulação das seleções user-defined.
Correção no script create_undef.pl.
A.1.13.3. Melhorias
Melhorias de pequenos desempenhos na função de entrada canonica.

Menor limpeza no carregador.
Suporte para nome de campo multibyte no carregador.
Melhorias no script no postgis_restore.pl.
Novo script util rebuild_bbox_caches.pl.
A.1.14. Versão 1.0.2

A.1.14.1. Melhorias
Se quiser melhorias de uma versão 1.0.0RC6 ou superior NÃO precisa descarregar/

recarregar.
Melhorias de versões anteriores requer um descarrega/recarrega. Veja o capítulo
upgrading para mais informações.
Falha tolerante do btree ops.

Memória de escape plugada em pg_error.
Índice fixo Rtree.
Scripts mais limpos na construção (mistura evitada de CFLAGS e CXXFLAGS).
A.1.14.3. Melhorias
Potencialidade na nova criação de índice no carregador (-I switch).

Suporte inicial para postgresql 8.1dev.
A.1.15. Versão 1.0.1
A.1.15.1. Melhorias
Se quiser melhorias de uma versão 1.0.0RC6 ou superior NÃO precisa descarregar/

recarregar.
Melhorias de versões anteriores requer um descarrega/recarrega. Veja o capítulo
A.1.15.2. Mudanças da Bibliotecas
CORREÇÃO na computação 3d de length_spheroid().

CORREÇÃO no estimador de seletividade agrupado.
A.1.15.3. Outras Mudanças/Adições
CORREÇÃO na função escape shp2pgsql.

Melhor suporte para concorrente postgis em esquemas múltiplos.
Documentações fixas.
jdbc2: compilar com "-target 1.2 -source 1.2" por padrão.
NOVO -k comutar para pgsql2shp.
NOVO suporte para opções createdb em postgis_restore.pl.
CORREÇÃO em nomes de atributos pgsql2shp cumprimento de unicidade.
CORREÇÃO em definições de projeções Paris.
limpezas postgis_restore.pl.
A.1.16. Versão 1.0.0
Versão final 1.0.0. Contem algumas correções, algumas melhorias no carregador (o mais
notavel suporte para versões postgis mais antigas) e mais documentações.
A.1.16.1. Melhorias
Se quiser melhorias de uma versão 1.0.0RC6 NÃO precisa descarregar/recarregar.

Melhorias de algumas versões anteriores requer um descarrega/recarrega. Veja o capítulo
CORREÇÃO no transform() liberando o endereço de memória aleatório.

CORREÇÃO no force_3dm() alocando menos memória então requerida.
CORREÇÃO no estimator de seletividade agrupado (defaults, leaks, tuplecount, sd).
A.1.16.3. Outras Mudanças/Adições
CORREÇÃO no escape de valores shp2pgsql começando com "tab" ou "single-quote".

NOVO páginas manuais para carregador/descarregador.
NOVO suporte shp2pgsql para antigas versões postgis (HWGEOM).
NOVO - p (prepare) flag para shp2pgsql.
NOVO capítulo manual sobre cumprimento de conformidade OGC.
NOVO suporte a autoconfiguração (autoconf) para biblioteca JTS.
CORREÇÃO nos verificadores do estimador (suporte para LWGEOM e esquema
analisador).
A.1.17. Versão 1.0.0RC6
Sexta Versão candidata para 1.0.0. Contem algumas correções e limpezas.
A.1.17.1. Melhorias
Você precisa descarregar/recarregar para melhoria das versões precedentes. Veja o

capítulo upgrading para mais informações.
CORREÇÃO em multi().
pronto return [when noop] do multi().
A.1.17.3. Mudanças de Scripts
funções dropped {x,y}{min,max}(box2d)

CORREÇÃO no script postgis_restore.pl.

CORREÇÃO no seu descarregador de suporte 64bit.
A.1.18. Versão 1.0.0RC5
Quinta Versão candidata para 1.0.0. Contem algumas correções e melhorias.
A.1.18.1. Melhorias
Se quiser melhorias de uma versão 1.0.0RC4 NÃO precisa descarregar/recarregar.

Melhorias de algumas versões anteriores requer um descarrega/recarrega. Veja o capítulo
CORREÇÃO (segmento padrão) em computação box3d (sim, outros!).

CORREÇÃO (segmento padrão) em estimated_extent().
Construções pequenas de scripts e refinamentos de utilidades.

Adicionais desempenho de tipos documentados.
A.1.19. Versão 1.0.0RC4
Quarta Versão candidata para 1.0.0. Contem correções e poucas melhorias.
A.1.19.1. Melhorias

CORREÇÃO (segmento padrão) em geom_accum().

CORREÇÃO no suporte a arquitetura 64bit.
CORREÇÃO no função da computação box3d com coleções.
NOVO suporte a subselects em estimador de seletividade.
Retorno rápido da force_collection.
Verificação de consistência fixa em SnapToGrid().
Saída retroagida Box2d para 15 dígitos significativos.
Box2d output changed back to 15 significant digits.
NOVO função distance_sphere().

Alterada implementação get_proj4_from_srid para usar PL/PGSQL em vez do SQL.
CORREÇÃO na manipulação do carregador e descarregador das formas MultiLine.

CORREÇÃO no carregador, saltando tudo com exceção da primeira regra de polígonos.
jdbc2: limpeza de códigos, melhorias no Makefile.
Variáveis FLEX e YACC atribui *after* pgsql Makefile.global que é incluído e só se a
versão pgsql *stripped* determina string vazia.Já adicionado analisador gerado na versão.
Refinamentos de scripts construídos.
Manipulação de versão melhorada, Version.config central.
melhorias em postgis_restore.pl.
A.1.20. Versão 1.0.0RC3

Terceira Versão candidata para 1.0.0. Contem muitas correções e melhorias.
A.1.20.1. Melhorias

CORREÇÃO no transform(): faltando SRID, manipulação melhor de erro.

CORREÇÃO na manipulação do alinhamento da memória.
CORREÇÃO no force_collection() causando falhas do conector do mapserver em tipos de
geometria simples.
CORREÇÃO no GeometryFromText() faltando adicionar uma memória bbox.
Precisão reduzida da saída box2d.
Macros DEBUG pré-fixados com PGIS_ para evitar o choque com um pgsql.
Ligado um escape no conversor GEOS2POSTGIS.
Uso de memória reduzido mais cedo liberando um "query-context" de um palloc.
CORREÇÃO em 72 índices sujeitantes.

CORREÇÃO no probe_geometry_columns() para trabalhar com PG72 e para suportar
colunas da geometria múltiplas em uma tabela simples.
NOVO cast bool::text
Feitas algumas funções IMMUTABLE de STABLE, para melhorar o desempenho.
A.1.20.4. Mudanças JDBC

jdbc2: Caminhos pequenos, testes box2d/3d, documentos e licença revisados.
jdbc2: Correções e o caso de teste para o tipo autoregistro pgjdbc 8.0.
jdbc2: Uso removido de jdk1.4 só características para permitir construção com versões
mais antigas JDK.
jdbc2: Adicionado suporte para construção com pg72jdbc2.jar.
jdbc2: Atualização e limpeza do makefile.
jdbc2: Adicionado suporte BETA para classes geometricas jts.
jdbc2: Pulo de testes known-to-fail contra servidores mais antigos PostGIS.
jdbc2: Fixado manipulação de medidas geométricas em EWKT.
Novo desempenho vira o capítulo no manual.

Atualizações da documentação: exigência pgsql72, lwpostgis.sql.
Poucas mudanças no autoconf.
A extração de BUILDDATE feito mais portável.
Fixado spatial_ref_sys.sql para evitar limpeza no banco de dados inteiro.
spatial_ref_sys: alteradas entradas Paris para combinar alguns distribuídos com o 0.x.
A.1.21. Versão 1.0.0RC2
Segunda Versão candidata para 1.0.0 contendo correções e algumas melhorias.

A.1.21.1. Melhorias

A.1.21.2. Mudanças em bibliotecas
CORREÇÃO na computação box3d pointarray.

CORREÇÃO na definição distance_spheroid.
CORREÇÃO no transform() faltando atualizar memória bbox.
NOVO jdbc driver (jdbc2).
GEOMETRYCOLLECTION(EMPTY) suporte de sintaxe para a compatibilidade inversa.
Saídas binárias mais rápidas.
Construtores mais estritos OGC WKB/WKT.
A.1.21.3. Mudanças em Scripts
Usos mais corretos STABLE, IMMUTABLE, STRICT em lwpostgis.sql.

construtores mais estritos OGC WKB/WKT.
Carregador mais rápido e mais robusto (ambos i18n e não).

script inicial do autoconf.
A.1.22. Versão 1.0.0RC1

Este é o primeiro candidato da principal versão postgis, com armazenamento interno dos
tipos postgis redesenhado para ser menor e mais rápido em seleções posicionadas.
A.1.22.1. Melhorias

A.1.22.2. Mudanças
Entrada canônica mais rápida.

Saída canônica de pouca perda.
EWKB binário canônico IO com PG>73.
Suporte para até coordenadas 4d, fornecendo a sem perda da conversão shapefile-
>postgis->shapefile.
Novas funções: UpdateGeometrySRID(), AsGML(), SnapToGrid(), ForceRHR(),
estimated_extent(), accum().
Posicionamento vertical de operadores indexados.
JOIN função de seletividade.
Mais geometrias construtores / editores.
API de extensão Postgis.
Suporte UTF8 no carregador.

Manual PostGIS

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Manual PostGIS

Diunggah oleh

Hak Cipta:

Format Tersedia

Manual PostGIS

Sandro Santilli <strk@refractions.net>

Chris Hodgson <chodgson@refractions.net>

Paul Ramsey <pramsey@refractions.net>

Jeff Lounsbury <jeffloun@refractions.net>

Dave Blasby <dblasby@gmail.com>

Bibliotecas de suportes importante

A biblioteca de projeção cartográfica Proj4 e o trabalho de Gerald Evenden and Frank

1.2. Mais Informações

• O software, a documentação e as novidades mais recentes do PostGIS estão

• Mais informações sobre a biblioteca de reprojeção Proj4 está disponível em http://

• Mais informações sobre o servidor da banco de dados PostgreSQL está disponível

• Mais informações sobre índice GiST está disponível no site de

• Mais informações sobre servidor de mapas na internet Mapserver está disponível

• As "características simples para especificação do SQL " está disponível no

PostGIS tem as seguintes exigências para construção e uso:

• Uma instalação completa do PostgreSQL (incluindo servidor de headers).

• O compilador de GNU C (gcc). Alguns outros compiladores de C ANSI podem ser

• (Opcional) Biblioteca de reprojeção Proj4. A biblioteca Proj4 é usada para fornecer

• (Opcional) Biblioteca de geometria GEOS. A biblioteca GEOS é usada para

O módulo de PostGIS é uma extensão ao PostgreSQL servidor de retaguarda. Assim,

1. Antes de você compilar os módulos do servidor de PostGIS, terá que compilar e

2. LDFLAGS=-lstdc++ ./configure [YOUR OPTIONS HERE]

4. Para recuperar o arquivo fonte PostGIS faça nova baixa em http://

• Bibliotecas são instaladas [pkglibdir]/lib/contrib.

• Arquivos de suporte importantes como lwpostgis.sql são instalados em

17. # createlang plpgsql [yourdatabase]

19. # psql -d [yourdatabase] -f lwpostgis.sql

21. Para um completo uso de coordenada de identificadores de definição de sistemas

22. # psql -d [yourdatabase] -f spatial_ref_sys.sql

Algumas distribuições empacotadas de PostGIS (em particular os instaladores Win32

# createdb -T template_postgis my_spatial_db

postgres=# CREATE DATABASE my_spatial_db

Infelizmente nem todas as definições podem ser substituídas facilmente em um banco de

PostGIS fornece uma proceduce SOFT UPGRADE para liberações menores ou de

2.2.2.1. Soft upgrade

Soft upgrade consiste do fonte de script lwpostgis_upgrade.sql em seu banco de dados

$ psql -f lwpostgis_upgrade.sql -d your_spatial_database

Se você não encontrar o arquivo lwpostgis_upgrade.sql, estará usando uma versão

$ utils/postgis_proc_upgrade.pl lwpostgis.sql > lwpostgis_upgrade.sql

Por HARD UPGRADE pretendemos descarregar/carregar (dump/reload) do banco de

Criar um "custom-format" para descarregar do banco de dados se quiser atualizar

$ pg_dump -Fc olddb > olddb.dump

$ grep ^KEEPING restore.log | less

$ psql newdb -c "ALTER TABLE geometry_columns DROP attrelid"

2.2.3. Problemas Comuns

1. Será mais fácil se você descomprimir os arquivos de PostGIS no diretório "contrib"

As extensões de JDBC provêem de objetos de Java correspondentes aos tipos de

2. Editar Makefile para prover os caminhos corretos de seu compilador de java

Os dados para o carregador e descarregador são construídos e instalados

Capítulo 3. Perguntas Mais Frequentes

3.1. Que tipo de objetos geométricos eu posso armazenar?

Você pode armazenar point, linestring, polygon, multipoint, multiline, multipolygon, e

CREATE TABLE gtest ( ID int4, NAME varchar(20) );

Para ver os dados de GIS na tabela:

SELECT id, name, AsText(geom) AS geom FROM gtest;

A maior seleção espatial incluem ambos um teste posicionado e um teste de função

SELECT id, the_geom FROM thetable

Seleções rápidas em tabelas grandes é uma finalidade da existência propriamente de

CREATE INDEX [indexname] ON [tablename]

Deverá também assegurar-se de que se a seleção de PostgreSQL tiver muita informação

Para versões de PostgreSQL 8.0.x e superiores, rode o comando VACUUM ANALYZE.

Para versões de PostgreSQL 7.4.x e inferiores, rode o comando SELECT