Todos os produtos
Search
Central de documentação

PolarDB:Modelo geométrico

Última atualização: Jun 28, 2026

O GanosBase Geometry é uma extensão de mecanismo espaço-temporal para o PolarDB for PostgreSQL. Ele implementa o padrão Simple Features Access (SFA) definido pelo Open Geospatial Consortium (OGC) e oferece um conjunto completo de ferramentas para armazenar, consultar e analisar objetos geométricos — desde pontos simples até curvas compostas e coleções de superfícies.

Conceitos principais

Hierarquia de tipos geométricos

Geometry é um tipo abstrato. Todos os valores geométricos concretos pertencem a um de seus subtipos, organizados em três categorias:

  • Tipos atômicos — formas indivisíveis: Point, LineString, Polygon

  • Tipos parametrizados — formas definidas por curvas exclusivas do GanosBase: EllipticalString, Bezier3Curve

  • Tipos de coleção — formas agrupadas: MultiPoint, MultiLineString, MultiPolygon, GeometryCollection, CompoundCurve, CurvePolygon

A seção Tipos de dados geométricos descreve cada subtipo em detalhes.

Dimensões de coordenadas

A geometria modela formas em um sistema de coordenadas 2D ou 3D. Cada coordenada possui um valor x e um valor y, podendo também conter:

Coordenada

Significado

Efeito na dimensão

x, y

Posição no plano

2D

z

Elevação ou profundidade

Adiciona uma terceira dimensão (3D)

m

Valor de medida — tempo, distância ou outra referência linear

Adiciona uma terceira dimensão (3D)

z + m juntos

Elevação e medida simultaneamente

4D

Se houver valores z ou m, defina-os para cada ponto da geometria.

Sistema de referência espacial

Um sistema de referência espacial (SRS) define como as coordenadas se mapeiam para um local específico na superfície da Terra. O GanosBase associa cada valor geométrico a um SRS por meio de um identificador inteiro chamado SRID. O SRID é uma chave estrangeira que referencia a tabela spatial_ref_sys.

Para mais detalhes, consulte Referência espacial.

Formatos de entrada suportados

O GanosBase aceita dados geométricos diretamente nestes formatos:

Formato

Tipo

Observações

Well-Known Text (WKT)

Texto

Padrão OGC; inclui tipo e coordenadas, sem SRID

Well-Known Binary (WKB)

Binário

Padrão OGC; portátil, precisão total; sem SRID

EKWT

Texto

Extensão do WKT pelo GanosBase; adiciona incorporação de SRID e suporte a 3DZ, 3DM, 4D

EKWB

Binário

Extensão do WKB pelo GanosBase; mesmas adições do EKWT

KML

XML

GML

XML

GeoHash

String

GeoJSON

JSON

RFC 7946

Qualquer valor WKT ou WKB válido também é válido como EKWT ou EKWB. Para outros formatos, como Esri Shapefiles, utilize uma ferramenta externa de importação antes de carregar os dados no GanosBase.

Tipos de dados geométricos

Tipos atômicos

Tipo

Descrição

Exemplo

Point

Geometria 0-dimensional que representa um único local no espaço de coordenadas

POINT (1 2), POINT Z (1 2 3), POINT ZM (1 2 3 4)

LineString

Linha unidimensional formada por uma sequência contígua de segmentos de reta; pode ter auto-interseção

LINESTRING (1 2, 3 4, 5 6)

Polygon

Região planar bidimensional delimitada por um limite exterior (shell) e zero ou mais limites interiores (buracos); cada limite é um LinearRing

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))

Tipos parametrizados

Estes tipos são específicos do GanosBase e utilizam parâmetros matemáticos em vez de sequências de pontos.

Tipo

Descrição

Exemplo

EllipticalString

Um arco elíptico

ELLIPTICALSTRING(-2 0,2 0,0 0,0,0,0,2,0.5)

Bezier3Curve

Curva de Bezier de terceira ordem definida por quatro pontos de controle

BEZIER3CURVE(1 1, 2 2, 3 2, 3 1)

Tipos de coleção

Tipo

Descrição

Exemplo

MultiPoint

Coleção de Points

MULTIPOINT ( (0 0), (1 2) )

MultiLineString

Coleção de LineStrings

MULTILINESTRING ( (0 0,1 1,1 2), (2 3,3 2,5 4) )

MultiPolygon

Coleção de Polygons não sobrepostos e não adjacentes; os Polygons podem se tocar em um número finito de pontos

MULTIPOLYGON (((1 5, 5 5, 5 1, 1 1, 1 5)), ((6 5, 9 1, 6 1, 6 5)))

GeometryCollection

Coleção heterogênea de quaisquer tipos geométricos

GEOMETRYCOLLECTION ( POINT(2 3), LINESTRING(2 3, 3 4))

CompoundCurve

Linha composta que combina segmentos retos, arcos elípticos e curvas de Bezier; o ponto final de cada componente deve coincidir com o ponto inicial do próximo

COMPOUNDCURVE((1 0,2 0),ELLIPTICALSTRING(2 0 ,4 0, 3 0 ,1,0,0,1,0.5))

CurvePolygon

Superfície fechada que pode conter limites curvos

CURVEPOLYGON(ELLIPTICALSTRING(2 0,2 0,0 0,0,0,0,2,0.5),CIRCULARSTRING(-0.5 0,0.5 0,-0.5 0))

Visualize geometry_columns

A view geometry_columns lê todas as colunas geométricas da tabela de catálogo do sistema do banco de dados. Ela segue a especificação Simple Features Specification for SQL definida pelo OGC.

Coluna

Tipo

Descrição

f_table_catalog

varchar(256)

Nome do banco de dados. Fixo como postgres.

f_table_schema

varchar(256)

Schema da tabela.

f_table_name

varchar(256)

Nome da tabela.

f_geometry_column

varchar(256)

Nome da coluna geométrica.

coord_dimension

integer

Dimensão da coordenada. Valores válidos: 2, 3 e 4.

srid

integer

SRID da coluna; chave estrangeira que referencia spatial_ref_sys.

type

varchar(30)

Tipo geométrico OGC. O valor GEOMETRY indica tipos mistos.

Consulte todas as colunas geométricas no banco de dados atual:

SELECT * FROM geometry_columns;

Índices espaciais

Os índices espaciais permitem que o GanosBase evite varreduras sequenciais globais no banco de dados ao processar grandes conjuntos de dados espaciais. Esses índices organizam os dados em uma estrutura de árvore percorrida rapidamente para localizar um registro específico.

O GanosBase oferece três tipos de índices espaciais:

Índice

Descrição

Mais indicado para

GiST (Generalized Search Tree)

Árvore de busca balanceada; alto desempenho em consultas; suporta regras personalizadas para distribuir qualquer tipo de dado e métodos de acesso customizados

Escolha padrão para a maioria das tabelas espaciais

BRIN (Block Range Index)

Armazena resumos no nível de bloco; tamanho muito menor e construção mais rápida que o GiST, mas com consultas mais lentas; exige manutenção manual; mais eficaz para consultas que retornam grande volume de registros

Tabelas muito grandes com pouca ou nenhuma sobreposição espacial (ex.: dados de pontos), quando as tabelas são estáticas ou mudam raramente

SP-GiST (Space-Partitioned Generalized Search Tree)

Suporta árvores de busca particionadas como quad-trees, k-d trees e radix trees; suporta menos operadores que o GiST e não oferece suporte a busca KNN

Objetos não sobrepostos; mais adequado que o GiST para objetos sem sobreposição

Casos de uso

  • Criação e visualização de mapas: Armazene estradas, rios, edifícios e outras feições cartográficas como valores geométricos e, em seguida, consulte-os e renderize-os por extensão espacial.

  • Serviços de localização: Execute consultas espaciais e agregações em dados de pontos para encontrar recursos próximos, calcular distâncias ou avaliar riscos geográficos.

  • Consultas de relacionamento espacial: Identifique como as feições se relacionam entre si — se há interseção, sobreposição, contenção ou adjacência.

  • Análise e medição espacial: Calcule áreas, comprimentos, distâncias e centroides em diferentes conjuntos de dados.

Início rápido

Esta seção orienta você na criação da extensão ganos_geometry, na definição de uma tabela geométrica, na importação de dados, na criação de índices e na execução de consultas espaciais.

Crie a extensão

-- Create the ganos_geometry extension.
CREATE EXTENSION ganos_geometry CASCADE;

Nota: Crie a extensão no schema public para evitar problemas de permissão.

CREATE EXTENSION ganos_geometry WITH SCHEMA public CASCADE;

Crie uma tabela geométrica

Existem dois métodos disponíveis. Utilize o Método 1 quando souber antecipadamente o tipo geométrico e o SRID.

Método 1 — Defina a coluna geométrica na instrução CREATE TABLE:

CREATE TABLE roads (
  id        int4,
  road_name varchar(25),
  geom      geometry(LINESTRING, 3857)
);

Método 2 — Adicione uma coluna geométrica a uma tabela existente:

CREATE TABLE roads (id int4, road_name varchar(25));
SELECT AddGeometryColumn('roads', 'geom', 3857, 'LINESTRING', 2);

Adicione uma restrição geométrica

ALTER TABLE roads ADD CONSTRAINT geometry_valid_check CHECK (ST_IsValid(geom));

Importe dados geométricos

Todas as seis linhas usam ST_GeomFromText para analisar strings WKT com SRID 3857.

INSERT INTO roads (id, geom, road_name) VALUES
  (1, ST_GeomFromText('LINESTRING(191232 243118,191108 243242)', 3857), 'North Fifth-Ring Road'),
  (2, ST_GeomFromText('LINESTRING(189141 244158,189265 244817)', 3857), 'East Fifth-Ring Road'),
  (3, ST_GeomFromText('LINESTRING(192783 228138,192612 229814)', 3857), 'South Fifth-Ring Road'),
  (4, ST_GeomFromText('LINESTRING(189412 252431,189631 259122)', 3857), 'West Fifth-Ring Road'),
  (5, ST_GeomFromText('LINESTRING(190131 224148,190871 228134)', 3857), 'East Chang''an Avenue'),
  (6, ST_GeomFromText('LINESTRING(198231 263418,198213 268322)', 3857), 'West Chang''an Avenue');

Consulte dados geométricos

SELECT id, ST_AsText(geom) AS geom, road_name FROM roads;

Saída esperada:

 id | geom                                    | road_name
----+-----------------------------------------+----------------------
  1 | LINESTRING(191232 243118,191108 243242) | North Fifth-Ring Road
  2 | LINESTRING(189141 244158,189265 244817) | East Fifth-Ring Road
  3 | LINESTRING(192783 228138,192612 229814) | South Fifth-Ring Road
  4 | LINESTRING(189412 252431,189631 259122) | West Fifth-Ring Road
  5 | LINESTRING(190131 224148,190871 228134) | East Chang'an Avenue
  6 | LINESTRING(198231 263418,198213 268322) | West Chang'an Avenue
(6 rows)

Crie um índice espacial

Índice GiST (recomendado):

-- Standard 2D GiST index:
CREATE INDEX <index_name> ON <table_name> USING GIST (<geometry_column>);

-- N-dimensional GiST index:
CREATE INDEX <index_name> ON <table_name> USING GIST (<geometry_column> gist_geometry_ops_nd);

-- Update statistics after building the index:
VACUUM ANALYZE <table_name> (<geometry_column>);

-- Example:
CREATE INDEX sp_geom_index ON roads USING GIST(geom);
VACUUM ANALYZE roads (geom);

Índice BRIN (tabelas grandes e predominantemente estáticas):

-- Standard BRIN index:
CREATE INDEX <index_name> ON <table_name> USING BRIN (<geometry_column>);

-- 3D or 4D BRIN index:
CREATE INDEX <index_name> ON <table_name> USING BRIN (<geometry_column> brin_geometry_inclusion_ops_3d);
CREATE INDEX <index_name> ON <table_name> USING BRIN (<geometry_column> brin_geometry_inclusion_ops_4d);

-- BRIN index with custom block size:
CREATE INDEX <index_name> ON <table_name> USING BRIN (<geometry_column>) WITH (pages_per_range = <number>);

Meça e analise dados espaciais

Os exemplos a seguir utilizam duas tabelas de amostra:

bc_roads        — columns: gid (integer), name (varchar), the_geom (geometry/LineString)
bc_municipality — columns: gid (integer), code (integer), name (varchar), the_geom (geometry/Polygon)

Calcule o comprimento total das estradas:

SELECT sum(ST_Length(the_geom)) / 1000 AS km_roads FROM bc_roads;
      km_roads
------------------
 70842.1243039643
(1 row)

Calcule a área de um município:

SELECT ST_Area(the_geom) / 10000 AS hectares
FROM bc_municipality
WHERE name = 'PRINCE GEORGE';
      hectares
------------------
 32657.9103824927
(1 row)

Execute consultas de relacionamento espacial

O GanosBase suporta o conjunto completo de funções de relacionamento espacial do OGC. Os exemplos abaixo demonstram padrões comuns.

ST_Contains — encontre estradas dentro de cada município:

SELECT m.name, sum(ST_Length(r.the_geom)) / 1000 AS roads_km
FROM bc_roads AS r, bc_municipality AS m
WHERE ST_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
 ...

ST_Covers — teste se um círculo cobre outro:

SELECT
  ST_Covers(smallc, smallc) AS smallinsmall,
  ST_Covers(smallc, bigc)   AS smallcoversbig,
  ST_Covers(bigc, ST_ExteriorRing(bigc)) AS bigcoversexterior,
  ST_Contains(bigc, ST_ExteriorRing(bigc)) AS bigcontainsexterior
FROM (
  SELECT
    ST_Buffer(ST_GeomFromText('POINT(1 2)'), 10) AS smallc,
    ST_Buffer(ST_GeomFromText('POINT(1 2)'), 20) AS bigc
) AS foo;
 smallinsmall | smallcoversbig | bigcoversexterior | bigcontainsexterior
--------------+----------------+-------------------+---------------------
 t            | f              | t                 | f
(1 row)

ST_Disjoint — teste se duas geometrias não compartilham pontos:

SELECT ST_Disjoint('POINT(0 0)'::geometry, 'LINESTRING ( 2 0, 0 2 )'::geometry);
 st_disjoint
-------------
 t
(1 row)
SELECT ST_Disjoint('POINT(0 0)'::geometry, 'LINESTRING ( 0 0, 0 2 )'::geometry);
 st_disjoint
-------------
 f
(1 row)

ST_Overlaps, ST_Crosses, ST_Intersects, ST_Contains — compare um ponto e uma linha:

SELECT
  ST_Overlaps(a, b)    AS a_overlap_b,
  ST_Crosses(a, b)     AS a_crosses_b,
  ST_Intersects(a, b)  AS a_intersects_b,
  ST_Contains(b, a)    AS b_contains_a
FROM (
  SELECT
    ST_GeomFromText('POINT(1 0.5)')             AS a,
    ST_GeomFromText('LINESTRING(1 0, 1 1, 3 5)') AS b
) AS foo;
 a_overlap_b | a_crosses_b | a_intersects_b | b_contains_a
-------------+-------------+----------------+--------------
 f           | f           | t              | t

ST_Relate — teste um padrão DE-9IM específico:

SELECT ST_Relate(
  ST_GeometryFromText('POINT(1 2)'),
  ST_Buffer(ST_GeometryFromText('POINT(1 2)'), 2),
  '0FFFFF212'
);
 st_relate
-----------
 t

ST_Touches — teste se as geometrias compartilham apenas um ponto de limite:

SELECT ST_Touches('LINESTRING(0 0, 1 1, 0 2)'::geometry, 'POINT(1 1)'::geometry);
 st_touches
------------
 f
(1 row)
SELECT ST_Touches('LINESTRING(0 0, 1 1, 0 2)'::geometry, 'POINT(0 2)'::geometry);
 st_touches
------------
 t
(1 row)

ST_Within — teste a contenção entre círculos com buffer:

SELECT
  ST_Within(smallc, smallc)              AS smallinsmall,
  ST_Within(smallc, bigc)                AS smallinbig,
  ST_Within(bigc, smallc)                AS biginsmall,
  ST_Within(ST_Union(smallc, bigc), bigc) AS unioninbig,
  ST_Within(bigc, ST_Union(smallc, bigc)) AS biginunion,
  ST_Equals(bigc, ST_Union(smallc, bigc)) AS bigisunion
FROM (
  SELECT
    ST_Buffer(ST_GeomFromText('POINT(50 50)'), 20) AS smallc,
    ST_Buffer(ST_GeomFromText('POINT(50 50)'), 40) AS bigc
) AS foo;
 smallinsmall | smallinbig | biginsmall | unioninbig | biginunion | bigisunion
--------------+------------+------------+------------+------------+------------
 t            | t          | f          | t          | t          | t
(1 row)

Acesse propriedades geométricas

Verifique se uma geometria é simples:

SELECT ST_IsSimple(ST_GeomFromText('POLYGON((1 2, 3 4, 5 6, 1 2))'));
 st_issimple
-------------
 t
(1 row)
SELECT ST_IsSimple(ST_GeomFromText('LINESTRING(1 1,2 2,2 3.5,1 3,1 2,2 1)'));
 st_issimple
-------------
 f
(1 row)

Encontre a maior cidade com anéis internos (rotatórias):

SELECT gid, name, ST_Area(the_geom) AS area
FROM bc_municipality
WHERE ST_NRings(the_geom) > 1
ORDER BY area DESC
LIMIT 1;
 gid | name   | area
-----+--------+------------------
  12 | Anning | 257374619.430216
(1 row)

Remova a extensão

-- Remove the ganos_geometry extension and all dependent objects.
DROP EXTENSION ganos_geometry CASCADE;

Próximos passos