As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Dados espaciais O Amazon Neptune agora oferece suporte a consultas espaciais, permitindo que você armazene e analise dados geométricos em seu gráfico. Embora sejam comumente usados para localizações geográficas (como coordenadas em um mapa), os recursos espaciais funcionam com qualquer dado bidimensional em que a posição e a proximidade sejam importantes. Use esse recurso para responder perguntas como “Quais lojas estão a menos de 5 milhas desse cliente?” , “Encontre todas as rotas de entrega que se cruzam com essa área de serviço” ou “Quais componentes dessa planta se sobrepõem à zona de HVAC?” O Neptune implementa suporte espacial usando funções de tipos espaciais padrão do setor que funcionam com pontos, polígonos e outras formas geométricas. Você pode armazenar dados espaciais como propriedades em nós e bordas e, em seguida, usar funções espaciais para calcular distâncias, verificar se os pontos estão dentro dos limites ou encontrar regiões sobrepostas, tudo dentro de suas consultas do OpenCypher. **Casos de uso comuns**: + **Aplicações geográficas**: recomendações baseadas em localização, delimitação geográfica, planejamento de rotas e análise de território + **Gerenciamento de instalações e espaços**: layouts de planta baixa, posicionamento de equipamentos e cobertura de zonas + **Topologia de rede**: mapeamento da infraestrutura física, áreas de cobertura e limites de serviço + **Design e CAD**: posicionamento de componentes, detecção de colisões e relações espaciais em projetos 2D + **Desenvolvimento do jogo**: posicionamento de personagens, detecção de colisões e cálculos area-of-effect A implementação de tipos espaciais no Amazon Neptune segue as diretivas 13249-3:2016, ISO/IEC assim como outros bancos de dados. Eles [Funções espaciais](access-graph-opencypher-22-spatial-functions.md) estão disponíveis na linguagem de consulta OpenCypher. ## Sistema de coordenadas Neptune tem um identificador de referência espacial (SRID) para um banco de dados inteiro. A homogeneidade do sistema de coordenadas reduz os erros do usuário nas consultas e melhora o desempenho do banco de dados. A primeira versão (1.4.7.0) suporta o sistema de coordenadas cartesianas, também conhecido como SRID 0. A implementação do SRID 0 no Neptune é compatível com valores de longitude e latitude. Use `ST_DistanceSpheroid` para calcular distâncias com base em WGS84 /SRID 4326. A implementação atual suporta o armazenamento de coordenadas tridimensionais. Atualmente, as funções espaciais suportam apenas o uso das coordenadas dos eixos x e y (bidimensionais). Atualmente, as coordenadas do eixo z não são suportadas pelas funções espaciais disponíveis. ## Armazenando dados de localização Armazene dados de localização em nós e bordas usando o tipo de propriedade Geometry. Crie valores de geometria a partir do formato Texto Conhecido (WKT), uma forma padrão de representar formas geográficas como texto. Por exemplo, para armazenar a localização de um ponto: ``` CREATE (n:airport {code: 'ATL', location: ST_GeomFromText('POINT (-84.4281 33.6367)')}) ``` Ao trabalhar com coordenadas geográficas, o primeiro argumento (x) representa a longitude e o segundo argumento (y) representa a latitude. Isso segue a ordem de coordenadas padrão usada em bancos de dados espaciais e o padrão ISO 19125. **nota** O Neptune agora suporta um novo tipo de dados chamado “Geometria”. A propriedade Geometry de um nó ou borda pode ser criada a partir de uma string WKT usando a `ST_GeomFromText` função. O Neptune armazenará automaticamente os dados de pontos em um índice espacial especializado para melhorar o desempenho das funções de tipos espaciais. Por exemplo, `ST_Contains` usado para encontrar os pontos dentro de um polígono é acelerado pelo índice espacial especializado. [Página da Wikipedia para representação de geometria em texto conhecido](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) ## Carregamento de dados espaciais em massa Ao carregar dados em massa, especifique o tipo de geometria no cabeçalho CSV. O Neptune analisará as cadeias de caracteres WKT e criará as propriedades geométricas apropriadas: ``` :ID,:LABEL,code:String,city:String,location:Geometry 21,airport,ATL,Atlanta,POINT (-84.42810059 33.63669968) 32,airport,ANC,Anchorage,POINT (-149.9960022 61.17440033) 43,airport,AUS,Austin,POINT (-97.66989899 30.19449997) ``` Para obter detalhes completos do formato CSV, consulte o formato de carregamento em massa do [OpenCypher.](bulk-load-tutorial-format-opencypher.md) ## Consultar dados espaciais Os exemplos de consulta a seguir usam o [conjunto de dados de rotas aéreas](https://github.com/krlawrence/graph/tree/main/sample-data) para demonstrar como usar funções espaciais em Netuno. Se seus dados tiverem propriedades separadas de latitude e longitude em vez de uma propriedade de geometria, você poderá convertê-los em pontos no momento da consulta. Encontre os 10 aeroportos mais próximos de um determinado local: ``` MATCH (a:airport) WITH a, ST_GeomFromText('POINT (' + a.lon + ' ' + a.lat + ')') AS airportLocation WITH a, airportLocation, ST_Distance(ST_GeomFromText('POINT (-84.4281 33.6367)'), airportLocation) AS distance WHERE distance IS NOT NULL RETURN a.code, a.city, distance ORDER BY distance ASC LIMIT 10 ``` Se você já tiver locais armazenados como`ST_Point`, poderá usar esses valores de localização diretamente: 1. Definir a propriedade de ``` MATCH (a:airport) SET a.location = ST_GeomFromText('POINT (' + a.lon + ' ' + a.lat + ')') ``` 1. Consulta usando ST\$1Distance: ``` MATCH (a:airport) WHERE a.location IS NOT NULL WITH a, ST_Distance(ST_GeomFromText('POINT (-84.4281 33.6367)'), a.location) AS distance RETURN a.code, a.city, distance ORDER BY distance ASC LIMIT 10 ``` ### Usando o driver Bolt A maioria dos métodos de consulta retorna valores de geometria como cadeias de caracteres WKT, que são legíveis por humanos. Se você estiver usando o driver Bolt, os valores de geometria serão retornados no formato WKB (binário conhecido) para maior eficiência. Converta WKB em um objeto de geometria em seu aplicativo: ``` try (Session session = driver.session()) { Result result = session.run("MATCH (n:airport {code: 'ATL'}) RETURN n.location as geom"); Record record = result.single(); byte[] wkbBytes = record.get("geom").asByteArray(); // Convert WKB to Geometry object using JTS library WKBReader wkbReader = new WKBReader(); Geometry geom = wkbReader.read(wkbBytes); } ``` # Funções espaciais As seguintes funções espaciais estão disponíveis no Neptune OpenCypher para trabalhar com tipos de dados de geometria: + [ST\$1Point](access-graph-opencypher-22-spatial-functions-st-point.md) + [ST\$1 GeomFromText](access-graph-opencypher-22-spatial-functions-st-geomfromtext.md) + [ST\$1 AsText](access-graph-opencypher-22-spatial-functions-st-astext.md) + [ST\$1 GeometryType](access-graph-opencypher-22-spatial-functions-st-geometrytype.md) + [ST\$1Equals](access-graph-opencypher-22-spatial-functions-st-equals.md) + [ST\$1Contains](access-graph-opencypher-22-spatial-functions-st-contains.md) + [ST\$1Intersects](access-graph-opencypher-22-spatial-functions-st-intersect.md) + [ST\$1Distance](access-graph-opencypher-22-spatial-functions-st-distance.md) + [ST\$1 DistanceSpheroid](access-graph-opencypher-22-spatial-functions-st-distancespheroid.md) + [ST\$1Envelope](access-graph-opencypher-22-spatial-functions-st-envelope.md) + [ST\$1Buffer](access-graph-opencypher-22-spatial-functions-st-buffer.md) # ST\$1Point ST\$1Point retorna um ponto dos valores das coordenadas de entrada. **Sintaxe** ``` ST_Point(x, y, z) ``` **Arguments (Argumentos)** + `x`- Um valor do tipo de dados DOUBLE PRECISION que representa uma primeira coordenada. + `y`- Um valor do tipo de dados DOUBLE PRECISION que representa uma segunda coordenada. + `z`- (opcional) **Ordem das coordenadas** Ao trabalhar com coordenadas geográficas, o primeiro argumento (`x`) representa a **longitude** e o segundo argumento (`y`) representa a **latitude**. Isso segue a ordem de coordenadas padrão usada em bancos de dados espaciais e o padrão ISO 19125. ``` // Correct: longitude first, latitude second ST_Point(-84.4281, 33.6367) // Atlanta airport // Incorrect: latitude first, longitude second ST_Point(33.6367, -84.4281) // This will return NaN in distance calculations ``` **Intervalos de coordenadas válidos** Para dados geográficos, certifique-se de que as coordenadas estejam dentro dos intervalos válidos: + Longitude (`x`): -180 a 180 + Latitude (`y`): -90 a 90 Coordenadas fora desses intervalos retornarão `NaN` (não é um número) quando usadas com funções de cálculo de distância, como`ST_DistanceSpheroid`. **Tipo de retorno** GEOMETRIA do subtipo PONTO Nulo será retornado se x ou y for nulo. **Exemplos** O seguinte constrói uma geometria de pontos a partir das coordenadas de entrada. ``` RETURN ST_Point(5.0, 7.0); POINT(5 7) ``` # ST\$1 GeomFromText ST\$1 GeomFromText constrói um objeto geométrico a partir de uma representação de texto bem conhecida (WKT) de uma geometria de entrada. **Sintaxe** ``` ST_GeomFromText(wkt_string) ``` **Arguments (Argumentos)** + `wkt_string`- Um valor do tipo de dados STRING que é uma representação WKT de uma geometria. **Tipo de retorno** GEOMETRY Se ewkb\$1string for nulo, será retornado null. Se wkt\$1string não for válido, a será retornado. BadRequestException **Exemplos** ``` RETURN ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))') POLYGON((0 0,0 1,1 1,1 0,0 0)) ``` # ST\$1 AsText ST\$1 AsText retorna a representação de texto bem conhecida (WKT) de uma geometria de entrada. **Sintaxe** ``` ST_AsText(geo) ``` **Arguments (Argumentos)** + `geo`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como uma GEOMETRIA. **Tipo de retorno** STRING Será retornado null, se geo for nulo. Se o parâmetro de entrada não for uma geometria, então a BadRequestException será retornado. Se o resultado for maior que uma STRING de 64 KB, um erro será retornado. **Exemplos** ``` RETURN ST_AsText(ST_GeomFromText('POLYGON((0 0,0 1,1 1,1 0,0 0))')) POLYGON((0 0,0 1,1 1,1 0,0 0)) ``` # ST\$1 GeometryType ST\$1 GeometryType retorna o tipo da geometria como uma string. **Sintaxe** ``` ST_GeometryType(geom) ``` **Arguments (Argumentos)** + `geom`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. **Tipo de retorno** STRING Nulo será retornado se geom for nulo. Se o parâmetro de entrada não for uma geometria, então a BadRequestException será retornado. **Exemplos** ``` RETURN ST_GeometryType(ST_GeomFromText('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)')); ST_LineString ``` # ST\$1Equals ST\$1equals retorna verdadeiro se as projeções 2D das geometrias de entrada forem topologicamente iguais. As geometrias são consideradas topologicamente iguais se tiverem conjuntos de pontos iguais. Em geometrias topologicamente iguais, a ordem dos vértices pode ser diferente, mantendo essa igualdade. **Sintaxe** ``` ST_Equals(geom1, geom2) ``` **Arguments (Argumentos)** + `geom1`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `geom2`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. Esse valor é comparado com geom1 para determinar se ele é igual a geom1. **Tipo de retorno** BOOLEAN Nulo será retornado se geom1 ou geom2 for nulo. Se geom1 ou geom2 não forem geometrias, então a será retornado. BadRequestException **Exemplos** ``` RETURN ST_Equals( ST_GeomFromText('POLYGON ((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))')); false ``` O seguinte verifica se as duas cadeias de linhas são geometricamente iguais. ``` RETURN ST_Equals( ST_GeomFromText('LINESTRING (1 0, 10 0)'), ST_GeomFromText('LINESTRING(1 0,5 0,10 0)')); true ``` # ST\$1Contains ST\$1Contains retornará true se a primeira geometria de entrada contiver a segunda geometria de entrada. A geometria A contém a geometria B se cada ponto em B for um ponto em A e seus interiores tiverem uma interseção não vazia. ST\$1Contains (A, B) é equivalente a ST\$1within (B, A). **Sintaxe** ``` ST_Contains(geom1, geom2) ``` **Arguments (Argumentos)** + `geom1`- Um valor do tipo GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `geom2`- Um valor do tipo GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. Esse valor é comparado com geom1 para determinar se ele está contido no geom1. **Tipo de retorno** BOOLEAN Nulo será retornado se geom1 ou geom2 for nulo. Se o parâmetro de entrada não for uma geometria, então a BadRequestException será retornado. **Exemplos** ``` RETURN ST_Contains( ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))')); false ``` # ST\$1Intersects ST\$1Intersects retorna true se as projeções 2D das duas geometrias de entrada tiverem pelo menos um ponto em comum. **Sintaxe** ``` ST_Intersects(geom1, geom2) ``` **Arguments (Argumentos)** + `geom1`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `geom2`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. **Tipo de retorno** BOOLEAN Nulo será retornado se geom1 ou geom2 for nulo. Se o parâmetro de entrada não for uma geometria, então a BadRequestException será retornado. **Exemplos** ``` RETURN ST_Intersects( ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(2 2,2 5,5 5,5 2,2 2))'), ST_GeomFromText('MULTIPOINT((4 4),(6 6))')); true ``` # ST\$1Distance Para geometrias de entrada, ST\$1Distance retorna a distância euclidiana mínima entre as projeções 2D dos dois valores de geometria de entrada. **Sintaxe** ``` ST_Distance(geo1, geo2) ``` **Arguments (Argumentos)** + `geo1`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `geo2`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como uma GEOMETRIA. **Tipo de retorno** PRECISÃO DUPLA nas mesmas unidades das geometrias de entrada. Se geo1 ou geo2 for nulo, então nulo será retornado. Se o parâmetro de entrada não for uma geometria, então a BadRequestException será retornado. **Exemplos** ``` RETURN ST_Distance( ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'), ST_GeomFromText('POLYGON((-1 -3,-2 -1,0 -3,-1 -3))')); 1.4142135623731 ``` # ST\$1 DistanceSpheroid Retorna a distância mínima em metros entre duas lon/lat geometrias. O esferóide é WGS84 /SRID 4326. **Sintaxe** ``` ST_DistanceSpheroid(geom1, geom2); ``` **Arguments (Argumentos)** + `geom1`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `geom2`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. **Tipo de retorno** FLOAT Nulo será retornado se geom for nulo. **Exemplos** ``` RETURN ST_DistanceSpheroid( ST_GeomFromText('POINT(-110 42)'), ST_GeomFromText('POINT(-118 38)')) 814278.77 ``` # ST\$1Envelope ST\$1Envelope retorna a caixa delimitadora mínima da geometria de entrada, da seguinte forma: + Se a geometria de entrada estiver vazia, a geometria retornada será POINT EMPTY. + Se a caixa delimitadora mínima da geometria de entrada se degenerar para um ponto, a geometria retornada será um ponto. + Se nenhuma das opções anteriores for verdadeira, a função retornará um counter-clockwise-oriented polígono cujos vértices são os cantos da caixa delimitadora mínima. Para todas as entradas não vazias, a função opera na projeção 2D da geometria de entrada. **Sintaxe** ``` ST_Envelope(geom) ``` **Arguments (Argumentos)** + `geom`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. **Tipo de retorno** GEOMETRY Nulo será retornado se geom for nulo. **Exemplos** ``` RETURN ST_Envelope(ST_GeomFromText("POLYGON ((2 1, 4 3, 6 1, 5 5, 3 4, 2 1))")) POLYGON ((2 1, 6 1, 6 5, 2 5, 2 1)) ``` # ST\$1Buffer ST\$1Buffer retorna uma forma geométrica 2D que representa todos os pontos cuja distância da forma geométrica inserida projetada no plano cartesiano xy é menor ou igual à distância inserida. **Sintaxe** ``` ST_Buffer(geom, distance, number_of_segments_per_quarter_circle) ``` **Arguments (Argumentos)** + `geom`- Um valor do tipo de dados GEOMETRY ou uma expressão que é avaliada como um tipo GEOMETRY. + `distance`- Um valor do tipo de dados DOUBLE PRECISION que representa a distância (ou raio) do buffer. + `number_of_segments_per_quarter_circle`- Um valor do tipo de dados INTEGER (deve ser maior ou igual a 0). Esse valor determina o número de pontos para aproximar um quarto de círculo em torno de cada vértice da forma geométrica inserida. Valores negativos assumem o valor zero por padrão. O padrão é 8. **Tipo de retorno** GEOMETRY A função ST\$1Buffer retorna uma forma geométrica bidimensional (2D) no plano cartesiano xy. **Exemplos** ``` RETURN ST_Buffer(ST_GeomFromText('LINESTRING (1 2,5 2,5 8)'), 2, 4); POLYGON ((3 4, 3 8, 3.1522409349774265 8.76536686473018, 3.585786437626905 9.414213562373096, 4.234633135269821 9.847759065022574, 5 10, 5.765366864730179 9.847759065022574, 6.414213562373095 9.414213562373096, 6.847759065022574 8.76536686473018, 7 8, 7 2, 6.847759065022574 1.2346331352698203, 6.414213562373095 0.5857864376269051, 5.765366864730179 0.1522409349774265, 5 0, 1 0, 0.2346331352698193 0.152240934977427, -0.4142135623730954 0.5857864376269051, -0.8477590650225737 1.2346331352698208, -1 2.0000000000000004, -0.8477590650225735 2.7653668647301797, -0.4142135623730949 3.414213562373095, 0.2346331352698206 3.8477590650225735, 1 4, 3 4)) ``` O seguinte retorna o buffer da geometria do ponto de entrada que se aproxima de um círculo. Como o comando especifica 3 como o número de segmentos por quarto de círculo, a função usa três segmentos para aproximar o quarto de círculo. ``` RETURN ST_Buffer(ST_GeomFromText('POINT (1 1)'), 1.0, 8)); POLYGON ((2 1, 1.9807852804032304 0.8049096779838718, 1.9238795325112867 0.6173165676349102, 1.8314696123025453 0.4444297669803978, 1.7071067811865475 0.2928932188134525, 1.5555702330196022 0.1685303876974548, 1.3826834323650898 0.0761204674887133, 1.1950903220161284 0.0192147195967696, 1 0, 0.8049096779838718 0.0192147195967696, 0.6173165676349103 0.0761204674887133, 0.444429766980398 0.1685303876974545, 0.2928932188134525 0.2928932188134524, 0.1685303876974546 0.4444297669803978, 0.0761204674887133 0.6173165676349102, 0.0192147195967696 0.8049096779838714, 0 0.9999999999999999, 0.0192147195967696 1.1950903220161284, 0.0761204674887132 1.3826834323650896, 0.1685303876974545 1.555570233019602, 0.2928932188134523 1.7071067811865475, 0.4444297669803978 1.8314696123025453, 0.6173165676349097 1.9238795325112865, 0.8049096779838714 1.9807852804032304, 0.9999999999999998 2, 1.1950903220161284 1.9807852804032304, 1.38268343236509 1.9238795325112865, 1.5555702330196017 1.8314696123025453, 1.7071067811865475 1.7071067811865477, 1.8314696123025453 1.5555702330196022, 1.9238795325112865 1.3826834323650905, 1.9807852804032304 1.1950903220161286, 2 1)) ```