Índice
GeometryGeometryPointCurveLineStringSurfacePolygonGeometryCollectionMultiPointMultiCurveMultiLineString (Multi Linhas)MultiSurface (Multi Superfícies)MultiPolygon (Multi Polígonos)GeometryO 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.
GeometryGeometryPointCurveLineStringSurfacePolygonGeometryCollectionMultiPointMultiCurveMultiLineString (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.
LineStrings 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
MultiPolygons 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
BLOBs 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)
GeometryDepois 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
GeralPointLineStringMultiLineStringPolygonMultiPolygonGeometryCollection
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 WHEREmysql>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 WHEREmysql>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) WHEREmysql>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) WHEREmysql>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.