Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Datos espaciales Amazon Neptune ahora admite consultas espaciales, lo que le permite almacenar y analizar datos geométricos en su gráfica. Si bien se utilizan habitualmente para ubicaciones geográficas (como las coordenadas de un mapa), las características espaciales funcionan con cualquier dato bidimensional en el que la posición y la proximidad sean importantes. Usa esta función para responder a preguntas como «¿Qué tiendas están a menos de 8 km de este cliente?» , «Busque todas las rutas de entrega que se crucen con esta área de servicio» o «¿Qué componentes de este plano de planta se superponen con la zona de HVAC?» Neptune implementa el soporte espacial mediante funciones de tipos espaciales estándares del sector que funcionan con puntos, polígonos y otras formas geométricas. Puede almacenar datos espaciales como propiedades en nodos y bordes y, a continuación, utilizar funciones espaciales para calcular distancias, comprobar si los puntos se encuentran dentro de los límites o buscar regiones superpuestas, todo ello dentro de sus consultas de OpenCypher. Casos de **uso comunes**: + **Aplicaciones geográficas**: recomendaciones basadas en la ubicación, geocercado, planificación de rutas y análisis del territorio + **Administración de instalaciones y espacios**: distribución de los planos de planta, ubicación de los equipos y cobertura de zonas + **Topología de la red**: mapeo de la infraestructura física, áreas de cobertura y límites de servicio + **Diseño y CAD**: posicionamiento de componentes, detección de colisiones y relaciones espaciales en diseños 2D + **Desarrollo del juego**: posicionamiento de personajes, detección de colisiones y area-of-effect cálculos La implementación de tipos espaciales en Amazon Neptune sigue las directivas ISO/IEC 13249-3:2016, al igual que otras bases de datos. [Funciones espaciales](access-graph-opencypher-22-spatial-functions.md)Están disponibles en el lenguaje de consulta OpenCypher. ## Sistema de coordenadas Neptune tiene un identificador de referencia espacial (SRID) para toda la base de datos. La homogeneidad del sistema de coordenadas reduce los errores de los usuarios al realizar consultas y mejora el rendimiento de la base de datos. La primera versión (1.4.7.0) admite el sistema de coordenadas cartesianas, también denominado SRID 0. La implementación del SRID 0 en Neptune es compatible con los valores de longitud y latitud. Se utiliza `ST_DistanceSpheroid` para calcular las distancias en función del WGS84 /SRID 4326. La implementación actual admite el almacenamiento de coordenadas tridimensionales. Actualmente, las funciones espaciales solo admiten el uso de las coordenadas de los ejes x e y (bidimensionales). Actualmente, las funciones espaciales disponibles no admiten las coordenadas del eje z. ## Almacenamiento de datos de ubicación Almacene los datos de ubicación en los nodos y las aristas mediante el tipo de propiedad Geometría. Cree valores geométricos a partir del formato de texto conocido (WKT), una forma estándar de representar formas geográficas como texto. Por ejemplo, para almacenar la ubicación de un punto: ``` CREATE (n:airport {code: 'ATL', location: ST_GeomFromText('POINT (-84.4281 33.6367)')}) ``` Al trabajar con coordenadas geográficas, el primer argumento (x) representa la longitud y el segundo argumento (y) representa la latitud. Esto sigue el orden de coordenadas estándar utilizado en las bases de datos espaciales y la norma ISO 19125. **nota** Neptune ahora admite un nuevo tipo de datos llamado «Geometría». La propiedad geométrica de un nodo o una arista se puede crear a partir de una cadena WKT mediante la `ST_GeomFromText` función. Neptune almacenará automáticamente los datos de puntos en un índice espacial especializado para mejorar el rendimiento de las funciones de tipos espaciales. Por ejemplo, el índice espacial especializado acelera el proceso que se `ST_Contains` utiliza para encontrar los puntos dentro de un polígono. [Página de Wikipedia sobre una conocida representación textual de la geometría](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) ## Carga de datos espaciales de forma masiva Al cargar datos de forma masiva, especifique el tipo de geometría en el encabezado de su CSV. Neptune analizará las cadenas WKT y creará las propiedades geométricas adecuadas: ``` :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 obtener información completa sobre el formato CSV, consulte el formato de carga masiva de [OpenCypher](bulk-load-tutorial-format-opencypher.md). ## Consulta de datos espaciales Los siguientes ejemplos de consultas utilizan el [conjunto de datos de rutas aéreas](https://github.com/krlawrence/graph/tree/main/sample-data) para demostrar cómo utilizar las funciones espaciales en Neptune. Si los datos tienen propiedades de latitud y longitud independientes en lugar de una propiedad geométrica, puede convertirlos en puntos en el momento de la consulta. Busque los 10 aeropuertos más cercanos a una ubicación determinada: ``` 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 ``` Si ya tienes ubicaciones almacenadas`ST_Point`, puedes usar esos valores de ubicación directamente: 1. Establecimiento de la propiedad de ``` MATCH (a:airport) SET a.location = ST_GeomFromText('POINT (' + a.lon + ' ' + a.lat + ')') ``` 1. Consulta mediante 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 ``` ### Uso del controlador Bolt La mayoría de los métodos de consulta devuelven los valores geométricos como cadenas WKT, que son legibles por humanos. Si utiliza el controlador Bolt, los valores geométricos se devuelven en formato WKB (conocido binario) para mejorar la eficiencia. Convierta WKB en un objeto geométrico en su aplicación: ``` 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); } ``` # Funciones espaciales Las siguientes funciones espaciales están disponibles en Neptune OpenCypher para trabajar con tipos de datos geométricos: + [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 devuelve un punto a partir de los valores de las coordenadas de entrada. **Sintaxis** ``` ST_Point(x, y, z) ``` **Argumentos** + `x`- Un valor del tipo de dato DOUBLE PRECISION que representa una primera coordenada. + `y`- Un valor del tipo de dato DOUBLE PRECISION que representa una segunda coordenada. + `z`- (opcional) **Orden de coordenadas** Cuando se trabaja con coordenadas geográficas, el primer argumento (`x`) representa la **longitud** y el segundo argumento (`y`) representa la **latitud**. Esto sigue el orden de coordenadas estándar utilizado en las bases de datos espaciales y la norma 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** En el caso de los datos geográficos, asegúrese de que las coordenadas estén dentro de rangos válidos: + Longitud (`x`): de -180 a 180 + Latitud (`y`): de -90 a 90 Las coordenadas fuera de estos rangos se devolverán `NaN` (no un número) cuando se usen con funciones de cálculo de distancia como`ST_DistanceSpheroid`. **Tipo de devolución** GEOMETRÍA del subtipo PUNTO Si x o y son null, entonces se devuelve el valor null. **Ejemplos** A continuación, se construye una geometría de puntos a partir de las coordenadas de entrada. ``` RETURN ST_Point(5.0, 7.0); POINT(5 7) ``` # ST\$1 GeomFromText ST\$1 GeomFromText construye un objeto geométrico a partir de una representación textual (WKT) conocida de una geometría de entrada. **Sintaxis** ``` ST_GeomFromText(wkt_string) ``` **Argumentos** + `wkt_string`- Un valor del tipo de dato STRING que es una representación en WKT de una geometría. **Tipo de devolución** GEOMETRY Si wkt\$1string es nulo, se devuelve el valor nulo. Si wkt\$1string no es válido, se devuelve a. BadRequestException **Ejemplos** ``` 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 devuelve la conocida representación textual (WKT) de una geometría de entrada. **Sintaxis** ``` ST_AsText(geo) ``` **Argumentos** + `geo`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado una GEOMETRÍA. **Tipo de devolución** STRING Si geom es nulo, entonces se devuelve el valor nulo. Si el parámetro de entrada no es una geometría, BadRequestException se devuelve a. Si el resultado es mayor que una CADENA de 64 KB, se devuelve un error. **Ejemplos** ``` 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 devuelve el tipo de geometría en forma de cadena. **Sintaxis** ``` ST_GeometryType(geom) ``` **Argumentos** + `geom`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. **Tipo de devolución** STRING Si geom es nulo, entonces se devuelve el valor nulo. Si el parámetro de entrada no es una geometría, BadRequestException se devuelve a. **Ejemplos** ``` 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 devuelve el valor true si las proyecciones 2D de las geometrías de entrada son topológicamente iguales. Las geometrías se consideran topológicamente iguales si tienen conjuntos de puntos iguales. En geometrías topológicamente iguales, el orden de los vértices puede diferir y, al mismo tiempo, mantener esta igualdad. **Sintaxis** ``` ST_Equals(geom1, geom2) ``` **Argumentos** + `geom1`- Un valor del tipo de datos GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. + `geom2`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. Este valor se compara con geom1 para determinar si es igual a geom1. **Tipo de devolución** BOOLEANO Si geom1 o geom2 son null, entonces se devuelve el valor null. Si geom1 o geom2 no son geometrías, se devuelve a. BadRequestException **Ejemplos** ``` 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 ``` Lo siguiente comprueba si las dos cadenas de líneas son geométricamente iguales. ``` RETURN ST_Equals( ST_GeomFromText('LINESTRING (1 0, 10 0)'), ST_GeomFromText('LINESTRING(1 0,5 0,10 0)')); true ``` # ST\$1Contains ST\$1Contains devuelve true si la proyección 2D de la primera geometría de entrada contiene la proyección 2D de la segunda geometría de entrada. La geometría A contiene la geometría B si todos los puntos de B son puntos de A y sus interiores no tienen una intersección vacía. ST\$1Contains (A, B) es equivalente a ST\$1Within (B, A). **Sintaxis** ``` ST_Contains(geom1, geom2) ``` **Argumentos** + `geom1`- Un valor de tipo GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. + `geom2`- Un valor de tipo GEOMETRÍA o una expresión que da como resultado un tipo de GEOMETRÍA. Este valor se compara con geom1 para determinar si está contenido dentro de geom1. **Tipo de devolución** BOOLEANO Si geom1 o geom2 son null, entonces se devuelve el valor null. Si el parámetro de entrada no es una geometría, BadRequestException se devuelve a. **Ejemplos** ``` 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 devuelve true si las proyecciones 2D de las dos geometrías de entrada tienen como mínimo un punto en común. **Sintaxis** ``` ST_Intersects(geom1, geom2) ``` **Argumentos** + `geom1`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. + `geom2`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. **Tipo de devolución** BOOLEANO Si geom1 o geom2 son null, entonces se devuelve el valor null. Si el parámetro de entrada no es una geometría, BadRequestException se devuelve a. **Ejemplos** ``` 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 En el caso de las geometrías de entrada, ST\$1Distance devuelve la distancia euclidiana mínima entre las proyecciones 2D de los dos valores de geometría de entrada. **Sintaxis** ``` ST_Distance(geo1, geo2) ``` **Argumentos** + `geo1`- Un valor del tipo de dato GEOMETRY o una expresión que dé como resultado un tipo de GEOMETRÍA. + `geo2`- Un valor del tipo de dato GEOMETRY o una expresión que dé como resultado una GEOMETRÍA. **Tipo de devolución** DOBLE PRECISIÓN en las mismas unidades que las geometrías de entrada. Si geo1 o geo2 son nulos, se devuelve un valor nulo. Si el parámetro de entrada no es una geometría, se devuelve a BadRequestException . **Ejemplos** ``` 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 Devuelve la distancia mínima en metros entre dos lon/lat geometrías. El esferoide es /SRID 4326. WGS84 **Sintaxis** ``` ST_DistanceSpheroid(geom1, geom2); ``` **Argumentos** + `geom1`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. + `geom2`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. **Tipo de devolución** FLOAT Si geom es nulo, entonces se devuelve el valor nulo. **Ejemplos** ``` RETURN ST_DistanceSpheroid( ST_GeomFromText('POINT(-110 42)'), ST_GeomFromText('POINT(-118 38)')) 814278.77 ``` # ST\$1Envelope ST\$1Envelope devuelve el cuadro delimitador mínimo de la geometría de entrada, de la siguiente manera: + Si la geometría de entrada está vacía, la geometría devuelta será POINT EMPTY. + Si el cuadro delimitador mínimo de la geometría de entrada degenera en un punto, la geometría devuelta es un punto. + Si nada de lo anterior es verdadero, la función devuelve un counter-clockwise-oriented polígono cuyos vértices son las esquinas del cuadro delimitador mínimo. Para todas las entradas no vacías, la función opera en la proyección 2D de la geometría de entrada. **Sintaxis** ``` ST_Envelope(geom) ``` **Argumentos** + `geom`- Un valor del tipo de dato GEOMETRÍA o una expresión que da como resultado un tipo de GEOMETRÍA. **Tipo de devolución** GEOMETRY Si geom es nulo, entonces se devuelve el valor nulo. **Ejemplos** ``` 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 devuelve una geometría 2D que representa todos los puntos cuya distancia desde la geometría de entrada proyectada en el plano cartesiano XY es menor o igual a la distancia de entrada. **Sintaxis** ``` ST_Buffer(geom, distance, number_of_segments_per_quarter_circle) ``` **Argumentos** + `geom`- Un valor del tipo de dato GEOMETRY o una expresión que da como resultado un tipo de GEOMETRÍA. + `distance`- Un valor del tipo de dato DOUBLE PRECISION que representa la distancia (o el radio) del búfer. + `number_of_segments_per_quarter_circle`- Un valor del tipo de dato INTEGER (debe ser mayor o igual a 0). Este valor determina el número de puntos que se aproximan a un cuarto de círculo en torno a cada vértice de la geometría de entrada. Los valores negativos son cero de forma predeterminada. El valor predeterminado es 8. **Tipo de devolución** GEOMETRY La función ST\$1Buffer devuelve geometría bidimensional (2D) en el plano cartesiano XY. **Ejemplos** ``` 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)) ``` A continuación, se devuelve el búfer de la geometría del punto de entrada que se aproxima a un círculo. Dado que el comando especifica 3 como el número de segmentos por cuarto de círculo, la función utiliza tres segmentos para aproximarse al cuarto 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)) ```