Índice
Geometry
Geometry
Point
Curve
LineString
Surface
Polygon
GeometryCollection
MultiPoint
MultiCurve
MultiLineString
(Multi Linhas)MultiSurface
(Multi Superfícies)MultiPolygon
(Multi Polígonos)Geometry
O MySQL 4.1 introduz extensões espaciais para permitir gerar, armazenar e analisar recursos geográficos. Atualmente estes recursos estão disponiveis apenas para tabelas MyISAM. Este capítulo cobre os seguintes tópicos:
A base destas extensões espaciais no modelo OpenGIS
Formato de dados para representação de dados espaciais
Como usar dados espaciais no MySQL
Uso do índice para dados espaciais
Diferenças do MySQL para a especificação OpenGIS
O MySQL implementea extensões espaciais seguindo especificações
do Open GIS Consortium
(OGC). Este é um
consórcio internacional com mais de 250 companhias, agências,
universidades participando no desenvolvimento de soluções
conceituais disponíveis publicamente que podem der úteis com
todos os tipos de aplicações que gerenciam dados espaciais. O
OGC mantém um web site em
http://www.opengis.org/.
Em 1997, o Open GIS Consortium publicou o OpenGIS (R) Simple Features Specifications For SQL (Especificações de Recursos OpenGIS (R) Simples Para SQL), um documento que propos diversos modos conceituais de para extender um SQL RDBMS para suportar dados espaciais. Esta especificação está disponível no web site do OpenGIS em http://www.opengis.org/techno/implementation.htm. Ele contém informações adicionais relevantes a este capítulo.
O MySQL implementa um subconjunto do ambiente SQL com Tipos Geométricos proposto pela OGC. Este termo se refere a um ambiente SQL que tem sido extendido com um conjunto de tipos geomértricos. Uma coluna SQL com valor geométrico é implementada como uma coluna de um tipo geométrico. As especificações descrevem um conjunto de tipod geométricos do SQL, bem como funções deste tipo para criar e analisar valores geométricos.
Um recurso geográfico é qualquer coisa no mundo que tem uma posição.
Um recurso pode ser:
Uma entidade. Por exemplo, uma montanha, uma lagoa, em cidade
Um espaço. Por exemplo, um área de código postal, os trópicos
Uma localização definida. Por exemplo, um cruzamento. como um lugar específico onde duas ruas se interceptam.
Você também pode encontrar documentos que utilizam o termo recurso geoespacial para se referir a recursos geográficos.
Geometria é outra palavra que denota um recurso geográfico. O significado original da palavra geometria denota um ramo da matemática. Outro significado vindo da cartografia, se referem aos recursos geométricos que os cartógrafos usam para mapear o mundo.
Este capítulo utiliza todos estes termos como sinônimo: recurso geográfico, recurso geoespacial, recurso ou geometria, O termo normalmente mais usado aqui é geometry.
Vamos definir uma geometria como um ponto ou um agregado de pontos representando alguma coisa no mundo que possui uma localização.
Geometry
Geometry
Point
Curve
LineString
Surface
Polygon
GeometryCollection
MultiPoint
MultiCurve
MultiLineString
(Multi Linhas)MultiSurface
(Multi Superfícies)MultiPolygon
(Multi Polígonos)O conjunto de tipos geométricos, proposto pelo ambiente SQL com Tipos Geométricos da OGC, é base do Modelo Geométrico OpenGIS. Neste modelo, cada objeto geométrico tem as seguintes propriedades gerais:
é associado com um Sistema de Referência Espacial, que descreve a coordenada espacial, na qual o objeto é definido.
pertence a alguma classe geométrica.
As classes geometry definem uma hierarquia como a seguir:
Geometry
(não-instanciável)
Point
(instanciável)
Curve
(não-instanciável)
LineString
(instanciável)
Line
LinearRing
Surface
(não-instanciável)
Polygon
(instanciável)
GeometryCollection
(instanciável)
MultiPoint
(instanciável)
MultiCurve
(não-instanciável)
MultiLineString
(instanciável)
MultiSurface
(não-instanciável)
MultiPolygon
(instanciável)
Algumas destas classes são abstratas (não-instanciável). Isto é, não é possível criar um objeto desta classe. Outras classes são instanciáveis e objetos podem ser criados deles. Cada classe tem propriedades e podem ter declarações (regras que definem intâncias de classes válidas).
Geometry
é a classe base. É uma classe
abstrata (não-instanciável). As subclasses instanciáveis de
Geometry
são restritas a objetos
geométricos de zero, uma e duas dimensões que existem no
espeaço de coordenadas bidimensional. Todas as classes
geométricas instanciáveis são definidas para que instâncias
válidas da classe geometry são topologicamente fechados (isto
é, todas as geometrias definidas incluem seus limites).
A classe base Geometry
tem subclasses para
Point
, Curve
,
Surface
e
GeometryCollection
:
Point
representam objetos sem dimensão.
Curve
representam para objetos de uma
dimensão, e tem a subclasse LineString
,
com subclasses Line
e
LinearRing
.
Surface
é criado para objetos
bidimensionais e tem a subclasse Polygon
.
GeometryCollection
tem classes de
coleção com zero-, uma- e duas-dimensões chamadas
MultiPoint
,
MultiLineString
e
MultiPolygon
para modelagem geométrica
correspondente a coleções de Points
,
LineStrings
e Polygons
respectivamente. MultiCurve
e
MultiSurface
são introduzidas como
superclasses abastratas que generalizam a interface de
coleção para tratar Curves
e
Surfaces
.
Geometry
, Curve
,
Surface
, MultiCurve
e
MultiSurface
são definidos como classes não
instanciáveis. Eles definem em conjunto de métodos comuns para
suas subclasses e incluidos por razões de extensabilidade.
Point
, LineString
,
Polygon
,
GeometryCollection
,
MultiPoint
,
MultiLineString
,
MultiPolygon
são classses instanciáveis.
Geometry
é a classe raiz da hierarquia. É
uma classe não instanciável mas possui vária propriedades
comuns a todos os valores de geometria de qualquer das
subclasses Geometry
. Estas propriedades
estão descritas na lista a seguir ( Subclasses particulares tem
as suas próprias propriedades específicas, descritas
posteriormente):
Propriedades de geometria
Um valor geometry tem as seguintes propriedades:
É o tipo (type). Cada geometria pertence a uma das classes instanciáveis na hierarquia.
Seu SRID ou Identificador de Referência Espacial. Este valor identifica o Sistema de Referência Espacial associada da geometria, o qual descreve o coordenada espacial na qual objeto geomtrico está definido.
Coordenadas (coordinates) em seu Sistema de Referência Espacial, representado por um número de precisão dupla (8 byte). Todas as geometrias não-vazias incluem pelo menos um par de coordenadas (X,Y). Geometrias vazias não contem cooredenadas.
Coordenadas estão relacionadas ao SRID. Por exemplo, em sistemas de coordenadas diferentes, a distância entre dois objetos podem diferir mesmo quando os objetos têm as mesmas coordenadas, porque as distâncias no sistema de coordenadas planar e a distância no sistema geocentrico (coordenadas na superfície da Terra) são coisas diferentes.
Seu interior (interior), limite (boundary) e exterior (exterior).
Todas as geometrias ocupam alguma porção no espaço. O exterior de uma geometria é todo espaço não ocupado pela geometria. O interiro é o espeaço ocupado pela geometria. O limite é a interface entre o interior e o exterior
Seu MBR (Retângulo de Limite Mínimo - Minimum Bounding Rectangle), ou Envelope, da geometria. Este é a geometria limitar, formado pelas coordenadas de mínimo e máximo (X,Y):
((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
A qualidade de ser simple
ou non-simple (simples ou
não simples). Valores geometricos alguns tipos
(LineString
,
Multipoint
,
MultiLineString
) podem ser simples ou
não-simples. Cada tipo determina sua prórpia afirmação
de ser simples ou não-simples.
A qualidade de ser closed
ou not closed (fechado ou
não fechado). Valores geométricos de alguns tipos
(LineString
,
MultiString
) podem ser fechado ou não
fechado. Cada tipo determina a sua própria afirmação de
ser fechado ou não fachado.
A qualidade de ser empty ou not empty (vazio ou não vazio). Uma geometria é vazia se ela não tem nenhum ponto. Exterior, interior e limite de ma geometria vazia não estão definidos. (isto é, eles são representados por valores NULL). Uma geometria vazia é definida sempre simples e ter um área de 0.
Sua dimensão (dimension). Uma geometria pode ter uma dimensão de −1, 0, 1 or 2:
−1 usado para geometrias vazias
0 usado para geometrias sem tamanho e sem area.
1 usado para geometrias com tamanho diferente de zero e sem area.
2 usado para geometrias com area diferente de zero.
Points
tem uma dimensião de zero.
LineStrings
tem uma dimensão de 1.
Polygons
tem uma dimensão de 2.
Dimensões de MultiPoints
,
MultiLineStrings
e
MultiPolygons
são a é mesma da
dimensão dos elementos dos quais eles consistem.
Um Point
é uma geometria que representa um
único local no espaço coordenado.
Exemplos de
Point
Imagine um mapa do munod de larga-escala com muitas cidades. Um ponto poderia representar cada cidade.
Em um mapa da cidade, um Point
poderia
epresntar uma parada de onibus.
Propriedades de
Point
Valor de coordenada X.
Valor da coordenada Y.
O Point
é definido como uma geometria de
dimensão zero.
O limite de um Point
é um conjunto
vazio.
Uma Curve
é uma geometria unidimensional,
normalmente representado por uma sequência de pontos.
Subclasses particulares de Curve
define o
tipo de interpolação entre pontos. Curve
é
uma classe não-instanciável.
Propriedades de
Curve
As coordenadas de seus pontos.
Curve
é definiido como uma geometria
unidimensional.
A Curve
é simples (simple) se ela não
passa pelo mesmo ponto duas vezes.
A Curve
é fechada (closed) se o ponto
inicial é igual ao ponto final.
O limite (boundary) de uma Curve
fechada
é vazio.
O limite (boundary) de uma Curve
não-fachada cociste do seus dois pontos finais.
A Curve
que é simples (simple) e fechada
(closed) é uma LinearRing
.
Uma LineString
é uma
Curve
com interpolação linear entre pontos.
Exemplos de
LineString
Em um mapa mundi uma LineStrings
poderia
representar os rios.
Um um mapa da cidade uma LineStrings
poderia respresntar ruas.
Propriedades
LineString
Coordenadas de segmentos LineString
definidos por cada par de pontos consecutivos.
Uma LineString
é uma
Line
, se ela consiste de exatamente dois
pontos.
A LineString
é uma
LinearRing
, se for fechada (closed) e
simples (simple).
Uma Surface
é uma geometria bidimensional.
Ele é uma classe não instanciável. Sua única subclasse
instanciável é Polygon
.
Propriedades de
Surface
Uma Surface
é definida com uma geomtria
bidimensional.
A especificação OpenGIS define uma
Surface
simples como uma geometria que
consiste de um único 'patch' que é associado com um
'exterior boundary' (limite exterior) e zero ou mais
'interior' boundaries (limites interiores).
O limite (boundary) de uma Surface
simples é o conjunto de curvas fechadas correspondente a
seus limites exterior e interior.
Um Polygon
é uma Surface
planar representando uma geometria multi-lados. Ela é definida
por um limite exterior e zero ou mais limites interiores, onde
cada limite interior define um buraco no
Polygon
.
Exemplos de
Polygon
Em um mapa de região, objetos Polygon
podem representar florestas, distritos, etc.
As afirmações para os polygons (as regras que definem polygons válidos) são:
O limite (boundary) de um Polygon
consiste de um conjunto de LinearRings (ex.
LineString
s que são simples e fechadas)
que fazem os seus limites interior e exterior.
Dois aneis no limite não podem se cruzar. Os aneis no
limite de um Polygon
podem se interseptar
em um Point
, mas apenas como uma
tangente.
Um Polygon
não pode ter linhas cortadas,
pontas ou cavidades.
O interior de cada Polygon
e um conjunto
de pontos conectados.
O Exterior de um Polygon
com um ou mais
buracos não está conectado. Cada buraco define um
componenete conectados do exterior.
Nas afirmações acimas, poligonos são geometrias simples.
Estas afirmações fazem de um Polygon
uma
geometria simples.
Um GeometryCollection
é uma geometria que é
um coleção de um ou mais geometrias de qualquer classe.
Todos os elementos em uma GeometryCollection
deve estar no mesmo Sistema de Referência Espacial (ex. no
mesmo sistema de coordenadas). GeometryCollection não coloca
nenhuma outra restrição em seus elementos, embora as
subclasses de GeometryCollection
descritas
abaixo possam restringir membros com base em:
Tipo de Elementos (por exemplo, um
MultiPoint
pode conter apenas elementos
Point
Dimensão.
Restrições no grau de sobreposição espacial entre elementos.
Um MultiPoint
é uma coleção de geometrias
compostas de elementos Point
. Os pontos não
estão conectados ou ordenados de forma alguma.
Exemplos de
MultiPoint
Em um mapa mundi, um Multipoint podia representar uma cadeia de pequenas ilhas.
Propriedades de
MultiPoint
MultiPoint
é definido com uma geometria
sem dimensão.
Um MultiPoint
é simples se não há dois
valores de seus Point
iguais no
MultiPoint
(tem valores de coordenadas
iguais).
O limite (boundary) de um MultiPoint
é
um conjunto vazio.
Uma MultiCurve
é uma coleção de geometria
compostas de elementos Curve
.
MultiCurve
é uma classe não instanciável.
Propriedades de
MultiCurve
A MultiCurve
é definida como uma
geometria de uma dimensão.
A MultiCurve
é simples se e somente se
todos os seus elementos são simples, a única interseção
entre quaisquer dois elementos ocorrem entre pontos que
estão nos limites (boundaries) de ambos os elementos.
O limite (boundary) de uma MultiCurve
é
obtida aplicando a "mod 2 union rule": Um ponto está no
limite (boundary) de uma MultiCurve
se
ele está no limite de um número ímpar de elementos da
MultiCurve
.
Um MultiCurve
é fechado se todos os seus
elementos são fechados.
O limite de uma MultiCurve
fechada e
sempre vazio.
Um MultiLineString
é uma coleção de
geométrias MultiCurve
composto de elementos
LineString
.
MultiLineString
Em uma mapa regional, um MultiLineString
pode represntar um rede hidrografica ou uma malha de
rodovias.
Um MultiSurface
é uma coleção geometrica
compostos de elementos de superfície MultiSurface é uma classe
não instanciável. Sua única subclasse instanciável é
MultiPolygon
Afirmações de
MultiSurface
O interior de quaisquer duas superfícies em uma
MultiSurface
não podem se interceptar.
O limite de quaiqsquer dois elementos em um
MultiSurface
podem interceptar em um
número finito de pontos.
Um MultiPolygon
é um objeto
MultiSurface
compostos de elementos
Polygon
.
Exemplos de
MultiPolygon
Em um mapa regional, um MultiPolygon
pode
representar um sistema de lagos.
As afirações dos
MultiPolygon
s são:
O interior de dois valores Polygon
que
são elementos de um MultiPolygon
não
podem interceptar.
Os limites (Boundaries) de quaisquer dois valores
Polygon
que são elementos de um
MultiPolygon
não podem cruzar e pode se
tocar em um número finito de pontos. (O cruzamento também
é proibido pela primeira afirmação.)
Um MultiPolygon
não pode ter linhas
cortadas, pontas ou cavidades. Um MultiPolygon é um
conjunto de pontos regular e fechado.
O interior de um MultiPolygon
composto
por mais de um Polygon
não está
conectado, o número de componentes conectados do interior
de um MultiPolygon
é igual ao número de
valores Polygon
no
MultiPolygon
.
Propriedades de
MultiPolygon
MultiPolygon é definido como uma geometria bidimensional.
O limite (boundary) de um MultiPolygon
é
um conjunto de curvas fechadas (valores
LineStrings
) correspondente ao limite dos
valores seus elementos Polygon
.
Cada Curve
no limite do
MultiPolygon
este no limite de exatamente
um elemento Polygon
.
Toda Curve
no limite de um elemento
Polygon está no limite do MultiPolygon
.
Esta seção descreve o formato de dados espaciais padrão que são utilizados para representar objetos geometry em consultas.
Eles são:
Formato Well-Known Text (WKT).
Formato Well-Known Binary (WKB).
Internamente, o MySQL armazena valores geometry em um formato que não é identico nem ao format WKT ou WKB.
A representação Well-Known Text (WKT) de
Geometry
é criada para troca de dados de
geometria na forma ASCII.
Exemplos de representações WKT representations de objetos geometry são:
Um Point
(ponto).
POINT(15 20)
Note que pontos coordenados são especificados sem separção por vírgulas.
Um LineString
(linha) com quatro pontos.
LINESTRING(0 0, 10 10, 20 25, 50 60)
Um Polygon
(polígono) com um anel
exterior e um anél interior.
POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7, 5 5))
Um MultiPoint
(multipontos) com três
valores Points
.
MULTIPOINT(0 0, 20 20, 60 60)
Um MultiLineString
(multi linhas) com
dois valores LineString
.
MULTILINESTRING((10 10, 20 20), (15 15, 30 15))
Um MultiPolygon
(multi polígonos) com
dois valores Polygon
.
MULTIPOLYGON(((0 0,10 0,10 10,0 10,0 0)),((5 5,7 5,7 7,5 7, 5 5)))
Um GeometryCollection
(Coleção de
Geometria) consistindo de dois valores
Points
e um
LineString
.
GEOMETRYCOLLECTION(POINT(10 10), POINT(30 30), LINESTRING(15 15, 20 20))
Uma gramática Backus-Naur que especifica as regras de produção formal para gravar valores WKT podem ser encontrados na documentação de especificação OGC indicada próximo ao início deste capítulo.
A representação Well-Known Binary (WKB) para valores geométricos é definida pela especificação OpenGIS. Ela também é definida no padrão ISO "SQL/MM Part 3: Spatial".
WKB é usado para trocar dados geometry como fluxos binários representados por valores BLOB contendop informações geométricas WKB.
WKB usa inteiros sem sinal de 1-byte e 4-byte e números de precisão dupla de 8-byte (formato IEEE 754). Um byte é 8 bits.
Por exemplo, um valor WKB que corresonde a POINT(1
1)
consiste desta sequência de 21 bytes (cada um
representado aqui por dois digitos hexa):
0101000000000000000000F03F000000000000F03F
A sequência pode ser quebrada nestes componentes:
Byte order : 01 WKB type : 01000000 X : 000000000000F03F Y : 000000000000F03F
A respresentação do componente está a seguir:
O byte order pode ser de 0 ou 1 para indicar o tipo little-endian ou big-endian. Os byte orders little-endian e big-endian também são conhecidos como Network Data Representation - Representação de Dados de Rede (NDR) e External Data Representation - Representação de Dados Externos (XDR), repectivamente.
O tipo WKB é um código que indica o tipo de geometria.
Valores de 1 a 7 indicam Point
,
LineString
, Polygon
,
MultiPoint
,
MultiLineString
,
MultiPolygon
, e
GeometryCollection
.
Um valor Point
têm coordenadas X e Y,
cada uma representada como um valor de dupla precisão.
Valores WKB para valores de geometria mais complexas são representados por estrutras de dados mais complexas, como detalhado na epecificação OpenGIS.
Esta seção descreve os tipos de dados que você pode usar para representar dados espaciais no MySQL e as funções disponíveis para criar e recuperar valores espaciais.
MySQL fornece um hierarquia de tipos de dados que correspondem as classes na hierarquia de classes do Modelo Geometrico OpenGIS. Alguns destes tipos guardam valores de geometria únicos:
GEOMETRY
POINT
LINESTRING
POLYGON
O tipo GEOMETRY
é o mais genérico destes
tipos, ele pode armazenar geometrias de qualquer tipo. Os outros
tipos restringem seus valores a tipos de geometria específicos.
Os outros tipos de dados tem coleções de valores:
MULTIPOINT
MULTILINESTRING
MULTIPOLYGON
GEOMETRYCOLLECTION
GEOMETRYCOLLECTION
pode armazenar uma
coleçao de objetos de qualquer tipo. Os outros tipos de
coleções restrigem o tipo dos membros da coleção para um
tipo de geometria específico.
Esta seção descreve como criar valores espaciais usando as funções Well-Known Text e Well-Known Binary que estão definidas no padrão OpenGIS, e usando funções específicas do MySQL.
O MySQL fornece algumas funções que utilizam a representação Well-Known Text (e, opcionalmente, um identificador sistema de referência espacial (SRID)) e retorna a geometria correspondente.
GeomFromText()
aceita um WKT de qualquer
tipo de geometria com seu primeiro argumento. Uma
implementação também fornece uma função de construção
específica do tipo para cada tipo de geometria.
GeomFromText(wkt[,srid])
,
GeometryFromText(wkt[,srid])
Controi um valor geometria de qualquer tipo usando sua representação WKT e SRID.
PointFromText(wkt[,srid])
Controi um valor POINT
usando sua
representação WKT e SRID.
LineFromText(wkt[,srid])
,
LineStringFromText(wkt[,srid])
Constroi um valor LINESTRING
usando sua
representação WKT e SRID.
PolyFromText(wkt[,srid])
,
PolygonFromText(wkt[,srid])
Constroi um valor POLYGON
usasdo sua
representação WKT e SRID.
MPointFromText(wkt[,srid])
,
MultiPointFromText(wkt[,srid])
Contrói um valor MULTIPOINT
usando sua
representação WKT e SRID.
MLineFromText(wkt[,srid])
,
MultiLineStringFromText(wkt[,srid])
Contrói um valor MULTILINESTRING
usando sua representação WKT e SRID.
MPolyFromText(wkt[,srid])
,
MultiPolygonFromText(wkt[,srid])
Contrói um valor MULTIPOLYGON
usando
sua representação WKT e SRID.
GeomCollFromText(wkt[,srid])
,
GeometryCollectionFromText(wkt[,srid])
Constrói um valor GEOMETRYCOLLECTION
usando sua representação WKT e SRID.
A especificação OpenGIS também descreve funções opcionais
para construção de valores Polygon
ou
MultiPolygon
baseados na representação
WKT de uma coleção de anéis ou valores
LineString
fechados. Estes valores podem se
interceptar. OMySQL ainda não implementou estas funções:
BdPolyFromText(wkt,srid)
Constrói um valor Polygon
a partir de
um valor MultiLineString
no formato WKT
contendo uma coleção arbitrária de valores
LineString
fechados.
BdMPolyFromText(wkt,srid)
Constrói um valor MultiPolygon
a
partir de um valor MultiLineString
no
formato WKT contendo uma coleção arbitrária de vlaores
LineString
fechados.
O MySQL fornece um conjunto de funções que utilizam um BLOB contendo representação Well-Known Binary (e, opcionalmente, um indentificador de sistema de referência espacial (SRID)), e retornam a geometria correspondente.
GeomFromWKT
pode acitar um WKB de qualquer
tipo de geometria como seu primeiro argumento. Uma
implementação também fornece uma função de construção
específica para cada tipo de geometria como descrito na lista
acima.
GeomFromWKB(wkb,srid)
,
GeometryFromWKB(wkt,srid)
Constrói um valor geometria de qualquer tipo usando seua representação WKB e SRID.
PointFromWKB(wkb[,srid])
Constrói um valor POINT
usando sua
representação WKB e SRID.
LineFromWKB(wkb[,srid])
,
LineStringFromWKB(wkb[,srid])
Constrói um valor LINESTRING
usando
sua representação WKB e SRID.
PolyFromWKB(wkb[,srid])
,
PolygonFromWKB(wkb[,srid])
Constrói um valor POLYGON
usando sua
representação WKB e SRID.
MPointFromWKB(wkb[,srid])
,
MultiPointFromWKB(wkb[,srid])
Constrói um valor MULTIPOINT
usando
sua representação WKB e SRID.
MLineFromWKB(wkb[,srid])
,
MultiLineStringFromWKB(wkb[,srid])
Constrói um valor MULTILINESTRING
usando sua representação WKB e SRID.
MPolyFromWKB(wkb[,srid])
,
MultiPolygonFromWKB(wkb[,srid])
Constrói um valor MULTIPOLYGON
usando
sua representação WKB e SRID.
GeomCollFromWKB(wkb[,srid])
,
GeometryCollectionFromWKB(wkt[,srid])
Constrói um valor GEOMETRYCOLLECTION
usando sua representação WKB e SRID.
A especificação do OpenGIS também descreve funções
adicionais para construção de valores
Polygon
ou MultiPolygon
baseados em uma representação WKB de uma coleção de anéis
ou valores de LineString
fechadas. Estes
valores podem se interceptar. O MySQL ainda não implementou
estas funções:
BdPolyFromWKB(wkb,srid)
Constrói um valor Polygon
a partir de
um valor MultiLineString
no formato WKB
contendo uma coleção arbitrária de valores
LineString
fechados.
BdMPolyFromWKB(wkb,srid)
Constrói um valor MultiPolygon
a
partir de um valor MultiLineString
no
formato WKB contendo uma coleção arbitrária de valores
LineString
fechados.
Nota: o MySQL aindo não implementou as funções listadas nesta seção.
O MySQL fornece um conjunto de funções úteis para criar
representações WKB de geometria. A função descrita nesta
seção são extensões MySQL para a especificação OpenGIS.
O resultado destas funções são valores
BLOB
s contendo representações WKB de
valores de geometria sem SRID. Os resultados destas funções
podem ser substituidos como primeiro argumento para a família
de funções GeomFromWKB()
.
Point(x,y)
Constrói um Point
WKB usando suas
cooerdenadas.
MultiPoint(pt1,pt2,...)
Constrói um MultiPoint
WKB usando
WKBPoints
. Quando o argumento não é
Point
WKB, o valor de retorno é
NULL
.
LineString(pt1,pt2,...)
Constrói um LineString
WKB de um
número de Points
WKB. Quando o
argumento não é Point
WKB, o valor de
retorno é NULL
. Quando o número de
Points
é menor que dois o valor de
retorno é NULL
.
MultiLineString(WKBLineString,WKBLineString,...,WKBLineString)
Constrói um MultiLineString
WKB usando
LineStrings
WKB. Quando o argumento
não é LineString
WKB, o valor de
retorno é NULL
.
Polygon(ls1,ls2,...)
Constrói um Polygon
de um número de
LineStrings
WKB. Quando o arguemnto
não representa o WKB de um LinearRing (ex.
LineString
não fechada e simples) o
valor de retorno é NULL.
MultiPolygon(poly1,poly2,...)
Constrói um MultiPolygon
WKB de um
conjunto de Polygons
WKB. Quando o
argumento não é um Polygon
WKB, o
valor de retorno é NULL
.
GeometryCollection(WKBGeometry,WKBGeometry,..,WKBGeometry)
Constucts a GeometryCollection
WKB.
Quando o argumento não é uma representação WKB bem
formada de uma geometria, o valor de retorno é
NULL
.
O MySQL fornece um modo padrão de criar colunas espaciais para
tipos de geometria, por exemplo, com CREATE
TABLE
ou ALTER TABLE
. Atualmente,
colunas espaciais são suportadas apenas por tabelas
MyISAM
.
CREATE TABLE
Use a instrução CREATE TABLE para criar uma tabela com uma coluna espacial:
mysql>CREATE TABLE geom (g GEOMETRY);
Query OK, 0 rows affected (0.02 sec) mysql>
ALTER TABLE
Use a instrução ALTER TABLE para adicionar ou deletar uma coluna espacial a ou de uma tabela existente:
mysql>ALTER TABLE geom ADD pt POINT;
Query OK, 0 rows affected (0.00 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql>ALTER TABLE geom DROP pt;
Query OK, 0 rows affected (0.00 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql>
Depois de criar as colunas espaciais, você pode preenchê-las com os dados espaciais.
Os valores devem ser armazenados no formato de geometria interna, mas você pode convertê-las para este formato a partir dos formatos Well-Known Text (WKT) ou Well-Known Binary (WKB). Os exemplos a seguir demonstram como inserir valores de geometria em uma tabela convertendo valores WKT em formatos de geometria interna.
Você pode realizar a conversão diretamente na instrução
INSERT
:
INSERT INTO geom VALUES (GeomFromText('POINT(1 1)')); SET @g = 'POINT(1 1)'; INSERT INTO geom VALUES (GeomFromText(@g));
Ou a coversão pode ser feita primeiro que o
INSERT
:
SET @g = GeomFromText('POINT(1 1)'); INSERT INTO geom VALUES (@g);
Os seguintes exemplos inserem geometrias mais comlexas nas tabelas:
SET @g = 'LINESTRING(0 0,1 1,2 2)'; INSERT INTO geom VALUES (GeomFromText(@g)); SET @g = 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7, 5 5))'; INSERT INTO geom VALUES (GeomFromText(@g)); SET @g = 'GEOMETRYCOLLECTION(POINT(1 1),LINESTRING(0 0,1 1,2 2,3 3,4 4))'; INSERT INTO geom VALUES (GeomFromText(@g));
Todos os exemplos anteiores usam
GeomFromText()
para criar os valores de
geometria. Você também pode usar funções de tipo
específicos:
SET @g = 'POINT(1 1)'; INSERT INTO geom VALUES (PointFromText(@g)); SET @g = 'LINESTRING(0 0,1 1,2 2)'; INSERT INTO geom VALUES (LineStringFromText(@g)); SET @g = 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7, 5 5))'; INSERT INTO geom VALUES (PolygonFromText(@g)); SET @g = 'GEOMETRYCOLLECTION(POINT(1 1),LINESTRING(0 0,1 1,2 2,3 3,4 4))'; INSERT INTO geom VALUES (GeomCollFromText(@g));
Note que se um programa aplicativo cliente que quiser utilizar representações WKB de valores de geometria, ele é responsável por enviar corretamente WKB formadas em consultas para o servidor. No entanto, existem diversos modos de satisfazer esta exigência. Por exemplo:
Inserindo um Point(1,1)
com sintaxe
literal hexa:
INSERT INTO geom VALUES (GeomFromWKB(0x0101000000000000000000F03F000000000000F03F));
Uma aplicação ODBC pode enviar uma representação WKB, ligando como um argumento do tipo BLOB:
INSERT INTO geom VALUES (GeomFromWKB(?));
Outra interfaces de programação podem suportar um mecanimo de placeholder similar.
Em um programa C, você pode fazer um escape de um valor
binário usando
mysql_real_escape_string()
e incluindo o
resultado em string de consulta que é enviada ao servidor.
See Secção 12.1.3.44, “mysql_real_escape_string()
”.
Valores de geometria, previamente armazenados na tabela, pode, ser buscados com a conversão em formatos internos. Você também pode convertê-los no formato WKT ou WKB.
Buscar valores de geometria usando formatos internos pode ser útil em transferências de tabela para tabela:
CREATE TABLE geom2 (g GEOMETRY) SELECT g FROM geom;
A função AsText()
fornece acesso textual
a valores de geometria. Ele converte a geometria a partir de
um formato interno em uma string WKT.
mysql> SELECT AsText(g) FROM geom;
+-------------------------+
| AsText(p1) |
+-------------------------+
| POINT(1 1) |
| LINESTRING(0 0,1 1,2 2) |
+-------------------------+
2 rows in set (0.00 sec)
Geometry
Depois de preencher colunas espaciais com valores, você está pronto para consultá-los e analisá-los. O MySQL fornece um conjunto de funções para realizar diversas operações em dados espaciais. Estas funções podem ser agrupadas em quatro grandes categorias de acordo com o tipo de operação que eles realizam:
Funções que convertem geometrias entre vários formatos.
Funções que fornecem acesso a propriedades qualitativas ou quantitativas de um geometria
Funções que descrevem realções entre duas geometrias.
Funções que criam novas geometrias de outras existentes.
Funções de análise espacial podem ser usados em muitos contextos, tais como:
Qualquer programa SQL interativo, como
mysql
ou MySQLCC
.
Aplicativos escritos em qualquer linguagem duportando uma API do cliente MySQL.
O MySQL suporta as seguintes funções para converter valores geométricos entre formatos internos e os formatos WKB e WKT:
GeomFromText(wkt[,srid])
Converte um valor string de sua representação WKT em
formato de geometria interna e retorna o resultado. Um
número de funções específicas de tipo também são
suportadas, como PointFromText()
e
LineFromText()
; veja
Secção 10.4.2.1, “Criando Valores Geometry Usando Funções WKT”.
GeomFromWKB(wkb [,srid])
Converte um valor binário da sua representação WKB em
formato de geometria interna e retorna o resultado. Um
número de funções específicas de tipo também são
suportadas, como PointFromWKB()
e
LineFromWKB()
; veja
Secção 10.4.2.2, “Criando Valores Geometry Usando Funções WKB”.
AsText(g)
Converte um valor em formato de geomtria interna em sua representação WKT e retorna a string resultante.
mysql>SET @g = 'LineString(1 1,2 2,3 3)';
mysql>SELECT AsText(GeomFromText(@g));
+--------------------------+ | AsText(GeomFromText(@G)) | +--------------------------+ | LINESTRING(1 1,2 2,3 3) | +--------------------------+
AsBinary(g)
Converte um valor em formato de geomtria interna em sua representação WKB e retorna o valor binário resultante
Geometry
em GeralPoint
LineString
MultiLineString
Polygon
MultiPolygon
GeometryCollection
Cada função que pertencem a este grupo tomam um valor de
geometria como seus argumentos e retornam alguma propriedade
quantitativa e qualitativa desta geometria. Algumas funções
restrigem os seus tipos de argumentos. tais funções retornam
NULL
se o argumento é de um tipo de
geometria incorreta. Por exemplo, Area()
retorna NULL
se o tipo do objeto não for nem
Polygon
nem MultiPolygon
.
As funções listadas nesta seção não restrigem seus argumentos e acitam um valor geometria de qualquer tipo.
GeometryType(g)
Retorna como string o nome do tipo da geometria da qual
esta instância g
de geometry é um
membro. O nome corresponderá a uma das subclasses
instanciáveis de Geometry
.
mysql> SELECT GeometryType(GeomFromText('POINT(1 1)'));
+-------------------------------------------------+
| GeometryType(GeomFromText('POINT(1 1)')) |
+-------------------------------------------------+
| POINT |
+-------------------------------------------------+
Dimension(g)
Retorna a dimensão herdada deste objeto
g
de geometria. O resultado pode ser
−1, 0, 1 or 2. (o significado destes valores é dado em
Secção 10.2.2, “Classe Geometry
”.)
mysql> SELECT Dimension(GeomFromText('LineString(1 1,2 2)'));
+------------------------------------------------+
| Dimension(GeomFromText('LineString(1 1,2 2)')) |
+------------------------------------------------+
| 1 |
+------------------------------------------------+
SRID(g)
Retorna um inteiro indicando ID do Sistema de Referência
Espacial do valor de geometria g
.
mysql> SELECT SRID(GeomFromText('LineString(1 1,2 2)'));
+-----------------------------------------------+
| SRID(GeomFromText('LineString(1 1,2 2)',101)) |
+-----------------------------------------------+
| 101 |
+-----------------------------------------------+
Envelope(geometry g):geometry
Retorna o Retângulo de Limite Mínimo (Minimum Bounding
Rectangle (MBR)) para o valor de geometria
g
. O resultado é retornado como um
polygon (polígono).
mysql> SELECT AsText(Envelope(GeomFromText('LineString(1 1,2 2)',101)));
+------------------------------------------------------+
| AsText(Envelope(GeomFromText('LineString(1 1,2 2)')) |
+------------------------------------------------------+
| POLYGON((1 1,2 1,2 2,1 2,1 1)) |
+------------------------------------------------------+
O polygon é definido pelos pontos nos cantos da caixa que o limita:
POLYGON((MINX MINY, MAXX MINY, MAXX MAXY, MINX MAXY, MINX MINY))
A especificação OpenGIS também define as seguintes funções, que o MySQL ainda não implementou:
Boundary(g)
Retorna uma geometria que é o fechamento do limite
combinacional do valor da geometria g
.
IsEmpty(g)
Retorna 1 se o valor da geometria g
e a
geometria vazia, 0 se ela não está vazia e −1 se o
argumento é NULL
. Se a geometria está
vazia, ela representa um conjunto de pontos vazios.
IsSimple(g)
Atualmewnte esta função não deve ser usada. Quando implementada, seu comportamento será como descrito no próximo parágrafo.
Retorna 1 se o valor da geometria g
não tem nenhum ponto geométrico anormal, como a
interseção própria ou tangente própria.
IsSimple
retorna 0 se o argumento não
é simples, e −1 se é NULL
.
A descrição de cada geométrica instanciável dada anteriormente neste capítulo inclui a condição específica que faz com que uma instância desta classe seja classificada como não simples.
Um Point
consiste de suas coordenadas X e
Y, que podem ser obtidas usando as seguintes funções:
X(p)
Retorna o valor da coordenada X para o ponto
p
como um número de dupla precisão.
mysql> SELECT X(GeomFromText('Point(56.7 53.34)'));
+--------------------------------------+
| X(GeomFromText('Point(56.7 53.34)')) |
+--------------------------------------+
| 56.7 |
+--------------------------------------+
Y(p)
Retorna o valor da coordenada Y para o ponto
p
como um número de dupla precisão.
mysql> SELECT Y(GeomFromText('Point(56.7 53.34)'));
+--------------------------------------+
| Y(GeomFromText('Point(56.7 53.34)')) |
+--------------------------------------+
| 53.34 |
+--------------------------------------+
Uma LineString
consiste de valores
Point
. Você pode extrair pontos
particulares de uma LineString
, contar o
número de pontos que ela contém ou obter o seu tamanho.
EndPoint(ls)
Retorna o Point
que é o ponto final do
valor LineString
ls
.
mysql> SELECT AsText(EndPoint(GeomFromText('LineString(1 1,2 2,3 3)')));
+------------------------------------------------------------+
| AsText(EndPoint(GeomFromText('LineString(1 1,2 2,3 3)'))) |
+------------------------------------------------------------+
| POINT(3 3) |
+------------------------------------------------------------+
GLength(ls)
Returna como um número de precisão dupla o tamanho do
valor LineString
ls
em sua referência espacial associada.
mysql> SELECT GLength(GeomFromText('LineString(1 1,2 2,3 3)'));
+--------------------------------------------------+
| GLength(GeomFromText('LineString(1 1,2 2,3 3)')) |
+--------------------------------------------------+
| 2.8284271247462 |
+--------------------------------------------------+
IsClosed(ls)
Returna 1 se o valor LineString
ls
é fechado (isto é, seus valores
StartPoint()
e
EndPoint()
são os mesmos). Returna 0
se ls
não é fechado, e −1 se ele é
NULL
.
mysql> SELECT IsClosed(GeomFromText('LineString(1 1,2 2,3 3)'));
+---------------------------------------------------+
| IsClosed(GeomFromText('LineString(1 1,2 2,3 3)')) |
+---------------------------------------------------+
| 0 |
+---------------------------------------------------+
NumPoints(ls)
retorna o número de pontos no valor
LineString
ls
.
mysql> SELECT NumPoints(GeomFromText('LineString(1 1,2 2,3 3)'));
+----------------------------------------------------+
| NumPoints(GeomFromText('LineString(1 1,2 2,3 3)')) |
+----------------------------------------------------+
| 3 |
+----------------------------------------------------+
PointN(ls,n)
Returna o n
-ésimo ponto no valor
Linestring
ls
.
mysql> SELECT AsText(PointN(GeomFromText('LineString(1 1,2 2,3 3)'),2));
+-----------------------------------------------------------+
| AsText(PointN(GeomFromText('LineString(1 1,2 2,3 3)'),2)) |
+-----------------------------------------------------------+
| POINT(2 2) |
+-----------------------------------------------------------+
StartPoint(ls)
Returna o Point
que é o ponto inicial
do valor LineString
ls
.
mysql> SELECT AsText(StartPoint(GeomFromText('LineString(1 1,2 2,3 3)')));
+-------------------------------------------------------------+
| AsText(StartPoint(GeomFromText('LineString(1 1,2 2,3 3)'))) |
+-------------------------------------------------------------+
| POINT(1 1) |
+-------------------------------------------------------------+
A especificação OpenGIS também define as seguintes funções, que o MySQL ainda não implementou:
GLength(mls)
Retorna o tamanho do valor de
MultiLineString
mls
como um número e precisão dupla. O tamanha de
mls
é igual a soma dos tamanhos de
seus elementos.
mysql> SELECT GLength(GeomFromText('MultiLineString((1 1,2 2,3 3),(4 4,5 5))'));
+-------------------------------------------------------------------+
| GLength(GeomFromText('MultiLineString((1 1,2 2,3 3),(4 4,5 5))')) |
+-------------------------------------------------------------------+
| 4.2426406871193 |
+-------------------------------------------------------------------+
IsClosed(MultiLineString m):Integer
,
IsClosed(mls)
Returna 1 se o valor MultiLineString
mls
é fechado (isto é, os valores
StartPoint()
e
EndPoint()
são os mesmos para cada
LineString
em mls
).
Returna 0 se mls
não é fechada, e
−1 se for NULL
.
mysql> SELECT IsClosed(GeomFromText('MultiLineString((1 1,2 2,3 3),(4 4,5 5))'));
+--------------------------------------------------------------------+
| IsClosed(GeomFromText('MultiLineString((1 1,2 2,3 3),(4 4,5 5))')) |
+--------------------------------------------------------------------+
| 0 |
+--------------------------------------------------------------------+
Area(poly)
Returna como um número de dupla precisão a área do
valor Polygon
poly
,
como medido em seu sistema de referência espacial.
mysql> SELECT Area(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))'));
+----------------------------------------------------------------------------+
| Area(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))')) |
+----------------------------------------------------------------------------+
| 8 |
+----------------------------------------------------------------------------+
NumInteriorRings(poly)
Retorna o número de anéis interiores no valor
Polygon
poly
.
mysql> SELECT NumInteriorRings(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))'));
+----------------------------------------------------------------------------------------+
| NumInteriorRings(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))')) |
+----------------------------------------------------------------------------------------+
| 1 |
+----------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
ExteriorRing(poly)
Retorna o anel exterior do valor
Polygon
poly
como
uma LineString
.
mysql> SELECT AsText(ExteriorRing(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))')));
+--------------------------------------------------------------------------------------------+
| AsText(ExteriorRing(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))'))) |
+--------------------------------------------------------------------------------------------+
| LINESTRING(0 0,0 3,3 3,3 0,0 0) |
+--------------------------------------------------------------------------------------------+
InteriorRingN(poly,n)
Retorna o n
-ésimo anel exterior para o
valor Polygon
poly
como uma LineString
.
mysql> SELECT AsText(InteriorRingN(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))'),1));
+-----------------------------------------------------------------------------------------------+
| AsText(InteriorRingN(GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))'),1)) |
+-----------------------------------------------------------------------------------------------+
| LINESTRING(1 1,1 2,2 2,2 1,1 1) |
+-----------------------------------------------------------------------------------------------+
A especificação OpenGIS também define as seguintes funções, que o MySQL ainda não implementou:
Area(mpoly)
Retorna como um número de precisão dupla a área do
valor MultiPolygon
mpoly
, como medido no sistema de
referência espacial deste
MultiPolygon
.
mysql> SELECT Area(GeomFromText('MultiPolygon(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))'));
+-----------------------------------------------------------------------------------+
| Area(GeomFromText('MultiPolygon(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))')) |
+-----------------------------------------------------------------------------------+
| 8 |
+-----------------------------------------------------------------------------------+
A especificação OpenGIS também define as seguintes funções, que o MySQL ainda não implementou:
NumGeometries(gc)
Retorna o número de geometrias no valor
GeometryCollection
gc
.
mysql> SELECT NumGeometries(GeomFromText('GeometryCollection(Point(1 1),LineString(2 2, 3 3))'));
+------------------------------------------------------------------------------------+
| NumGeometries(GeomFromText('GeometryCollection(Point(1 1),LineString(2 2, 3 3))')) |
+------------------------------------------------------------------------------------+
| 2 |
+------------------------------------------------------------------------------------+
GeometryN(gc,n)
Retorna o n
-ésima geometria no valor
GeometryCollection
gc
. O número de geometrias começa em
1.
mysql> SELECT AsText(GeometryN(GeomFromText('GeometryCollection(Point(1 1),LineString(2 2, 3 3))'),1));
+------------------------------------------------------------------------------------------+
| AsText(GeometryN(GeomFromText('GeometryCollection(Point(1 1),LineString(2 2, 3 3))'),1)) |
+------------------------------------------------------------------------------------------+
| POINT(1 1) |
+------------------------------------------------------------------------------------------+
Nota: Funções para tipos de
geometrias específicas retornam NULL
se a
geomtria passada é do tipo de geometria errado. Por exemplo
Area()
retorna NULL
se o
tipo do objeto não é nem Polygon nem
MultiPolygon
.
Na seção Secção 10.5.2, “Funções de Análise das Propriedades de Geometry
” nós
já discutimos algumas funções que podem construir novas
geometrias se outras existentes:
Envelope(g)
StartPoint(ls)
EndPoint(ls)
PointN(ls,n)
ExteriorRing(poly)
InteriorRingN(poly,n)
GeometryN(gc,n)
OpenGIS propõem algumas outras funções que podem produzir geometrias. Elas estão designadas a implementar Operadores Espaciais.
Estas funções ainda não estão implementadas no MySQL. Elas devem aparecer em distribuições futuras.
Intersection(g1,g2)
Retorna uma geometria que representa a insterseção do
conjunto de pontos dos valores das geometrias
g1
com g2
.
Union(g1,g2)
Retorna uma geometria que representa a união do conjunto
de pontos dos valores das geometrias g1
com g2
.
Difference(g1,g2)
Retorna uma geometria que representa a diferença do
conjunto de pontos dos valores das geometrias
g1
com g2
.
SymDifference(g1,g2)
Retorna uma geometria que representa a diferença
simétrica do conjunto de pontos dos valores das
geometrias g1
com
g2
.
Buffer(g,d)
Retiorna uma geometria que representa todos os pontos cuja
distância do valor da geometria g
é
menor que ou igual a distância de d
.
ConvexHull(g)
Retorna uma geometria que representa a casca convexa de do
valor da geometria g
.
A função descrita nesta seção toma duas geometrias como parâmetros de entrada e retorna uma relação qualitativa ou quantitativa entre eles.
O MySQL fornece algumas funções que podem testar relações
entre retângulos de limite mínimo de duas geometrias
g1
e g2
. Elas incluem:
MBRContains(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de g1
contém o Retângulo de
Limite Mínimo de g2
.
mysql>SET @g1 = GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');
mysql>SET @g2 = GeomFromText('Point(1 1)');
mysql>SELECT MBRContains(@g1,@g2), MBRContains(@g2,@g1);
----------------------+----------------------+ | MBRContains(@g1,@g2) | MBRContains(@g2,@g1) | +----------------------+----------------------+ | 1 | 0 | +----------------------+----------------------+
MBRWithin(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de g1
esta dentro do Retângulo
de Limite Mínimo de g2
.
mysql>SET @g1 = GeomFromText('Polygon((0 0,0 3,3 3,3 0,0 0))');
mysql>SET @g2 = GeomFromText('Polygon((0 0,0 5,5 5,5 0,0 0))');
mysql>SELECT MBRWithin(@g1,@g2), MBRWithin(@g2,@g1);
+--------------------+--------------------+ | MBRWithin(@g1,@g2) | MBRWithin(@g2,@g1) | +--------------------+--------------------+ | 1 | 0 | +--------------------+--------------------+
MBRDisjoint(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de duas geometrias g1
e
g2
não fazem interseção.
MBREqual(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de duas geometrias g1
e
g2
são o mesmo.
MBRIntersects(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de duas geometrias g1
e
g2
se interseptam.
MBROverlaps(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de duas geometrias g1
e
g2
se sobrepõe.
MBRTouches(g1,g2)
Retorna 1 ou 0 para indicar se o Retângulo de Limite
Mínimo de duas geometrias g1
e
g2
se tocam.
A especificação OpenGIS define as seguintes funções, que o MySQL ainda não implementou. Elas devem aparecer em distribuições futuras. Quando implementadas, fornecerão suporte total para análise espacial, não apenas suporte baseado em MBR.
As funções operam em dois valores de geometria
g1
e g2
.
Contains(g1,g2)
Retorna 1 ou 0 para indicar se g1
contem
completamente g2
ou não.
Crosses(g1,g2)
Retorna 1 se g1
cruza espacialmente
g2
. Retorna NULL
se
g1
é um Polygon
ou um
MultiPolygon
, ou se g2
é um Point
ou um
MultiPoint
. Senão 0 é retornado.
O termo spatially crosses denota uma relação espacial entre duas geometrias que têm as seguintes propriedades:
As duas geometrias se interseptam
A interseção resulta em uma geometria que tem uma dimensão que é menor que a dimensão máxima das duas geometrias dadas.
A interseção não é igual a nenhuma das duas geometrias dadas.
Disjoint(g1,g2)
Retorna 1 ou 0 para indicar se g1
é
espacialmente disjunta de g2
ou não.
Equals(g1,g2)
Retorna 1 ou 0 para indicar se g1
é
espacialmente igual a g2
ou não.
Intersects(g1,g2)
Retorna 1 ou 0 para indicar se g1
intersepta espacialmente g2
ou não.
Overlaps(g1,g2)
Retorna 1 ou 0 para indicar se g1
sobrepõe espacialmente a g2
ou não. O
termo sobrepor espacialmente
é usado se
duas geometrias fazem interseção e suas interseções
resultam em uma geometria da mesma dimensão mas difernete
de ambas as geometrias dadas.
Touches(g1,g2)
Retorna 1 ou 0 para indicar se g1
spatially touches g2
, ou não. Duas
geometrias se tocam espacialmente se o interiro de ambas
geometrias não se interseptam, mas o limite de uma delas
intersepta o limite ou o interior das geometrias.
Within(g1,g2)
Retorna 1 ou 0 para indicar se g1
está
espacialmente dentro da g2
, ou não.
Distance(g1,g2)
Retorna como um número de precisão dupla, a menor distância entre quaiquer dois pontos nas duas geometrias.
Related(g1,g2,pattern_matrix)
Retorna 1 ou 0 indicando se o relacionamento espacial
especificado por matriz_padrão
existe
entre g1
e g2
ou não.
Retorna −1 se os argumentos são NULL
.
A matriz padrão é uma string. Sua especificação será
indicada aqui quando esta função estiver implementada.
É sabido que operações de busca em banco de dados não espaciais podem ser otimizadas utilizando índices. Isto ainda é verdade em banco de dados espaciais. Com a ajuda de grande variedades de métodos de indexacão multi-dimensionais, o quais já têm sido desenvolvidos, é possível otimizar buscas espaciais. As mais comuns delas são:
Consulta de ponto que buscam por todos os objetos que contem um dado ponto.
Consulta de região que buscam por todos os objetos que sobrepõe uma dada região.
O MySQL utiliza Arvores R com separação quadrática para indexar colunas espaciais. Um índice espacial é construído usando o MBR de uma geometria. Para a maioria da geometrias, o MBR é um retângulo mínimo que cerca a geometria. Para uma linha (linestring) horizontal ou uma vertical, o MBR é um retângulo degenerado, nas linhas e nos pontos respectivamente.
O MySQL pode criar índices espaciais usando uma sintaxe similar
àquela usada para criar índices regulares, mas extendida com a
palavra-chave SPATIAL
. Colunas espaciais
indexadas devem ser declaradas como NOT NULL
.
Os seguintes exemplos demonstram como criar índices de colunas
espaciais.
Com CREATE TABLE
:
mysql> CREATE TABLE geom (g GEOMETRY NOT NULL, SPATIAL INDEX(g));
Com ALTER TABLE
:
mysql> ALTER TABLE geom ADD SPATIAL INDEX(g);
Com CREATE INDEX
:
mysql> CREATE SPATIAL INDEX sp_index ON geom (g);
Para remover índices espaciais, use ALTER
TABLE
ou DROP INDEX
:
Com ALTER TABLE
:
mysql> ALTER TABLE geom (ADD SPATIAL KEY(g));
Com DROP INDEX
:
mysql> DROP INDEX sp_index ON geom;
Example: Suponha que uma tabela geom
contém
mais de 32000 geometrias, que estão armazenadas na coluna
g
do tipo GEOMETRY
. A
tabela também tem um campo AUTO_INCREMENT
fid
, armazenando valores dos IDs de objetos.
mysql>SHOW FIELDS FROM geom;
+-------+----------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------+----------+------+-----+---------+----------------+ | fid | int(11) | | PRI | NULL | auto_increment | | g | geometry | | | | | +-------+----------+------+-----+---------+----------------+ 2 rows in set (0.00 sec) mysql>SELECT COUNT(*) FROM geom;
+----------+ | count(*) | +----------+ | 32376 | +----------+ 1 row in set (0.00 sec)
Para adicionar um índice espacial na coluna
g
, use esta instrução:
mysql> ALTER TABLE geom ADD SPATIAL INDEX(g);
Query OK, 32376 rows affected (4.05 sec)
Records: 32376 Duplicates: 0 Warnings: 0
O otimizador investiga se os índices espaciais disponíveis
podem ser envolvidos na busca se uma consulta com uma função
como MBRContains()
ou
MBRWithin()
na cláusula
WHERE
é executada. Por exemplo, suponhamos
que queremos encontrar todos os objetos que estão no retângulo
dado:
mysql>SELECT fid,AsText(g) FROM geom WHERE
mysql>MBRContains(GeomFromText('Polygon((30000 15000,31000 15000,31000 16000,30000 16000,30000 15000))'),g);
+-----+-----------------------------------------------------------------------------+ | fid | AsText(g) | +-----+-----------------------------------------------------------------------------+ | 21 | LINESTRING(30350.4 15828.8,30350.6 15845,30333.8 15845,30333.8 15828.8) | | 22 | LINESTRING(30350.6 15871.4,30350.6 15887.8,30334 15887.8,30334 15871.4) | | 23 | LINESTRING(30350.6 15914.2,30350.6 15930.4,30334 15930.4,30334 15914.2) | | 24 | LINESTRING(30290.2 15823,30290.2 15839.4,30273.4 15839.4,30273.4 15823) | | 25 | LINESTRING(30291.4 15866.2,30291.6 15882.4,30274.8 15882.4,30274.8 15866.2) | | 26 | LINESTRING(30291.6 15918.2,30291.6 15934.4,30275 15934.4,30275 15918.2) | | 249 | LINESTRING(30337.8 15938.6,30337.8 15946.8,30320.4 15946.8,30320.4 15938.4) | | 1 | LINESTRING(30250.4 15129.2,30248.8 15138.4,30238.2 15136.4,30240 15127.2) | | 2 | LINESTRING(30220.2 15122.8,30217.2 15137.8,30207.6 15136,30210.4 15121) | | 3 | LINESTRING(30179 15114.4,30176.6 15129.4,30167 15128,30169 15113) | | 4 | LINESTRING(30155.2 15121.4,30140.4 15118.6,30142 15109,30157 15111.6) | | 5 | LINESTRING(30192.4 15085,30177.6 15082.2,30179.2 15072.4,30194.2 15075.2) | | 6 | LINESTRING(30244 15087,30229 15086.2,30229.4 15076.4,30244.6 15077) | | 7 | LINESTRING(30200.6 15059.4,30185.6 15058.6,30186 15048.8,30201.2 15049.4) | | 10 | LINESTRING(30179.6 15017.8,30181 15002.8,30190.8 15003.6,30189.6 15019) | | 11 | LINESTRING(30154.2 15000.4,30168.6 15004.8,30166 15014.2,30151.2 15009.8) | | 13 | LINESTRING(30105 15065.8,30108.4 15050.8,30118 15053,30114.6 15067.8) | | 154 | LINESTRING(30276.2 15143.8,30261.4 15141,30263 15131.4,30278 15134) | | 155 | LINESTRING(30269.8 15084,30269.4 15093.4,30258.6 15093,30259 15083.4) | | 157 | LINESTRING(30128.2 15011,30113.2 15010.2,30113.6 15000.4,30128.8 15001) | +-----+-----------------------------------------------------------------------------+ 20 rows in set (0.00 sec)
Agora verifiquemos o modo que esta consulta é executada, usando
EXPLAIN
:
mysql>EXPLAIN SELECT fid,AsText(g) FROM geom WHERE
mysql>MBRContains(GeomFromText('Polygon((30000 15000,31000 15000,31000 16000,30000 16000,30000 15000))'),g);
+----+-------------+-------+-------+---------------+------+---------+------+------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+-------+-------+---------------+------+---------+------+------+-------------+ | 1 | SIMPLE | geom | range | g | g | 32 | NULL | 50 | Using where | +----+-------------+-------+-------+---------------+------+---------+------+------+-------------+ 1 row in set (0.00 sec)
Agora verifiquemos o que aconteceria se nós não tivéssemos índices espaciais:
mysql>EXPLAIN SELECT fid,AsText(g) FROM geom IGNORE INDEX (g) WHERE
mysql>MBRContains(GeomFromText('Polygon((30000 15000,31000 15000,31000 16000,30000 16000,30000 15000))'),g);
+----+-------------+-------+------+---------------+------+---------+------+-------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+-------+------+---------------+------+---------+------+-------+-------------+ | 1 | SIMPLE | geom | ALL | NULL | NULL | NULL | NULL | 32376 | Using where | +----+-------------+-------+------+---------------+------+---------+------+-------+-------------+ 1 row in set (0.00 sec)
Vamos executar a consulta acima, ignorando a chave espacial que temos:
mysql>SELECT fid,AsText(g) FROM geom IGNORE INDEX (g) WHERE
mysql>MBRContains(GeomFromText('Polygon((30000 15000,31000 15000,31000 16000,30000 16000,30000 15000))'),g);
+-----+-----------------------------------------------------------------------------+ | fid | AsText(g) | +-----+-----------------------------------------------------------------------------+ | 1 | LINESTRING(30250.4 15129.2,30248.8 15138.4,30238.2 15136.4,30240 15127.2) | | 2 | LINESTRING(30220.2 15122.8,30217.2 15137.8,30207.6 15136,30210.4 15121) | | 3 | LINESTRING(30179 15114.4,30176.6 15129.4,30167 15128,30169 15113) | | 4 | LINESTRING(30155.2 15121.4,30140.4 15118.6,30142 15109,30157 15111.6) | | 5 | LINESTRING(30192.4 15085,30177.6 15082.2,30179.2 15072.4,30194.2 15075.2) | | 6 | LINESTRING(30244 15087,30229 15086.2,30229.4 15076.4,30244.6 15077) | | 7 | LINESTRING(30200.6 15059.4,30185.6 15058.6,30186 15048.8,30201.2 15049.4) | | 10 | LINESTRING(30179.6 15017.8,30181 15002.8,30190.8 15003.6,30189.6 15019) | | 11 | LINESTRING(30154.2 15000.4,30168.6 15004.8,30166 15014.2,30151.2 15009.8) | | 13 | LINESTRING(30105 15065.8,30108.4 15050.8,30118 15053,30114.6 15067.8) | | 21 | LINESTRING(30350.4 15828.8,30350.6 15845,30333.8 15845,30333.8 15828.8) | | 22 | LINESTRING(30350.6 15871.4,30350.6 15887.8,30334 15887.8,30334 15871.4) | | 23 | LINESTRING(30350.6 15914.2,30350.6 15930.4,30334 15930.4,30334 15914.2) | | 24 | LINESTRING(30290.2 15823,30290.2 15839.4,30273.4 15839.4,30273.4 15823) | | 25 | LINESTRING(30291.4 15866.2,30291.6 15882.4,30274.8 15882.4,30274.8 15866.2) | | 26 | LINESTRING(30291.6 15918.2,30291.6 15934.4,30275 15934.4,30275 15918.2) | | 154 | LINESTRING(30276.2 15143.8,30261.4 15141,30263 15131.4,30278 15134) | | 155 | LINESTRING(30269.8 15084,30269.4 15093.4,30258.6 15093,30259 15083.4) | | 157 | LINESTRING(30128.2 15011,30113.2 15010.2,30113.6 15000.4,30128.8 15001) | | 249 | LINESTRING(30337.8 15938.6,30337.8 15946.8,30320.4 15946.8,30320.4 15938.4) | +-----+-----------------------------------------------------------------------------+ 20 rows in set (0.46 sec)
Quando o índice não é usado, o tempo de execução para esta consulta cresce de 0.00 segundos para 0.46 segundos.
Nas verões futuras, índices espaciais também serão usados para otimizar outras funções. See Secção 10.5.4, “Funções Para Testar Relações Espaciais Entre Objetos Geométricos”.
Views de Metadados Adicionais
Especificações OpenGIS propõe várias views adicionais de
metadados. Por exemplo, um sistema de view chamado
GEOMETRY_COLUMNS
contem uma descrição
de colunas geometria, uma linha para coda coluna de
geometria no banco de dados.
Funções para adicionar/apagar colunas espaciais
OpenGIS assume que colunas podem ser adcionados ou apagados
usando funções AddGeometryColumn()
e
DropGeometryColumn()
. No MySQL isto deve
ser feito utilizando as instruções ALTER
TABLE
, CREATE INDEX
e
DROP INDEX
Itens relacionados a Sistema de Referência Espaciasi e suas IDs (SRIDs):
Funções como Length()
e
Area()
assumem um sistemas de
coordenadas planas.
Todos os objetos são ataulmente considerados como estando no mesmo sistema de coordenadas planas.
A função OpenGIS Length()
em
LineString
e
MultiLineString
atualmente devem ser chamadas como
GLength()
no MySQL. O problema é que ela
conflita com a função SQL existente
Length()
que calcula o tamanho de um
valor string e algumas vezes não é possível distinguir se
a função foi chamada co contexto textual ou espacial. Nós
precisamos resolver isto de algum modo, ou escolher um outro
nome de função.
This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.