Forem: Prof. Ms. Ricardo Leme

Geospatial Query in MongoDB

Prof. Ms. Ricardo Leme — Fri, 10 Nov 2023 19:04:50 +0000

The geospatial data in MongoDB refers to information associated with specific locations on the Earth's surface. This type of data is commonly represented using the GeoJSON format, which supports various geometries such as points, lines, and polygons. MongoDB provides dedicated features for working with geospatial data, enabling efficient storage, retrieval, and analysis of location-related information.

When should I use it?

Location-Based Applications: Geospatial data in MongoDB is especially useful for applications that rely on location information, such as map services, location-based searches, and geofencing. Storing and querying geospatial data allows the development of apps offering location-sensitive features.
Proximity Searches: When you need to find locations near a specific point, geospatial data comes in handy. This is beneficial for applications like store locators, restaurant finders, or any service involving recommendations based on proximity.
Spatial Analysis: If your application involves analyzing relationships and patterns in spatial data, MongoDB's geospatial capabilities can help. For instance, you can analyze the distribution of points, identify clusters, or perform spatial calculations.
Geofencing: Geofencing involves defining virtual boundaries in the real world and triggering actions when a device enters or exits these boundaries. Geospatial data in MongoDB enables the efficient implementation of geofencing logic.
Route Optimization: For applications requiring route planning or optimization, geospatial data can be used to represent and query paths, helping find the most efficient routes between locations.

Inserting Geospatial Data

To insert geospatial data, you can use the GeoJSON data type and the 2dsphere spatial index. Here's an example of inserting a point:

db.locations.insert({
  name: "City Center",
  location: {
    type: "Point",
    coordinates: [longitude, latitude]
  }
});

Basic Proximity Query:

To find locations near a specific coordinate, you can use the $nearSphere operator:

db.locations.find({
  location: {
    $nearSphere: {
      $geometry: {
        type: "Point",
        coordinates: [longitude, latitude]
      },
      $maxDistance: 1000 // Maximum distance in meters
    }
  }
});

Query with Polygons:

You can also perform queries within defined areas using polygons. Let's perform a query to find all locations within a specific polygon. Suppose the polygon is defined by the following coordinates:

const polygon = [
  [-43.200, -22.920],
  [-43.200, -22.900],
  [-43.180, -22.900],
  [-43.180, -22.920],
  [-43.200, -22.920]
];

The MongoDB query will look like this:

db.locations.find({
  location: {
    $geoWithin: {
      $geometry: {
        type: "Polygon",
        coordinates: [polygon]
      }
    }
  }
});

LineString Query

The LineString query in MongoDB allows finding documents in a collection whose geospatial data, represented as continuous paths (lines), intersects with a specific line. It is useful for identifying, for example, paths that pass through a certain route or area.

To perform this query, use the $geoIntersects operator in combination with the LineString data type and the coordinates of the desired line in GeoJSON format. This functionality is valuable in applications involving path analysis, routes, or any scenario where the intersection of geospatial lines is relevant.

Practical Example of LineString Usage

Suppose you have a collection called "routes" that stores information about different paths, each represented by a document with a "path" field in GeoJSON format. Let's create an example by inserting some data and perform a query to find routes that intersect with a specific line.

Inserting Example Data

Let's insert some example data representing routes:

db.routes.insert({
  name: "Route A",
  path: {
    type: "LineString",
    coordinates: [
      [-43.200, -22.910],
      [-43.190, -22.905],
      [-43.180, -22.900]
    ]
  }
});

db.routes.insert({
  name: "Route B",
  path: {
    type: "LineString",
    coordinates: [
      [-43.185, -22.915],
      [-43.175, -22.910],
      [-43.165, -22.905]
    ]
  }
});

// Insert other routes as needed

Performing LineString Query

Now, let's perform a query to find routes that intersect with a specific line. Suppose the line is defined by the following coordinates:

const line = [
  [-43.195, -22.912],
  [-43.185, -22.907],
  [-43.175, -22.902]
];

The MongoDB query will look like this:

db.routes.find({
  path: {
    $geoIntersects: {
      $geometry: {
        type: "LineString",
        coordinates: line
      }
    }
  }
});

Summary

Geospatial data in MongoDB is a powerful feature for handling location-based information. It is beneficial in scenarios where understanding and utilizing spatial relationships enhance the functionality and efficiency of your application.

References

https://www.mongodb.com/docs/manual/geospatial-queries/

Introdução aos Dados Geoespaciais no MongoDB

Prof. Ms. Ricardo Leme — Fri, 10 Nov 2023 18:54:18 +0000

Os dados geoespaciais no MongoDB referem-se a informações associadas a locais específicos na superfície da Terra. Esse tipo de dado é comumente representado usando o formato GeoJSON, que suporta várias geometrias, como pontos, linhas e polígonos. O MongoDB fornece recursos dedicados para trabalhar com dados geoespaciais, permitindo o armazenamento eficiente, recuperação e análise de informações relacionadas à localização.

Quando devo utilizar?

Aplicações Baseadas em Localização: Os dados geoespaciais no MongoDB são especialmente úteis para aplicações que dependem de informações de localização, como serviços de mapas, pesquisas baseadas em localização e geofencing. Armazenar e consultar dados geoespaciais permite a construção de aplicativos que oferecem recursos sensíveis à localização.
Pesquisas por Proximidade: Quando você precisa encontrar locais próximos a um ponto específico, dados geoespaciais são úteis. Isso é benéfico para aplicativos como localizadores de lojas, buscadores de restaurantes ou qualquer serviço que envolva recomendações com base na proximidade.
Análise Espacial: Se sua aplicação envolve a análise de relacionamentos e padrões em dados espaciais, as capacidades geoespaciais do MongoDB podem ajudar. Por exemplo, você pode analisar a distribuição de pontos, identificar clusters ou realizar cálculos espaciais.
Geofencing: Geofencing envolve definir limites virtuais no mundo real e acionar ações quando um dispositivo entra ou sai desses limites. Os dados geoespaciais no MongoDB permitem a implementação eficiente de lógica de geofencing.
Otimização de Rotas: Para aplicativos que exigem planejamento ou otimização de rotas, dados geoespaciais podem ser usados para representar e consultar caminhos, ajudando a encontrar as rotas mais eficientes entre locais.

Inserindo Dados Geoespaciais

Para inserir dados geoespaciais, você pode usar o tipo de dado GeoJSON e o índice espacial 2dsphere. Aqui está um exemplo de inserção de um ponto:

  db.locations.insert({
  name: "Centro da Cidade",
  location: {
    type: "Point",
    coordinates: [longitude, latitude]
  }
});

Consulta Básica de Proximidade:

Para encontrar locais próximos a uma coordenada específica, você pode usar o operador $nearSphere:

db.locations.find({
  location: {
    $nearSphere: {
      $geometry: {
        type: "Point",
        coordinates: [longitude, latitude]
      },
      $maxDistance: 1000 // Distância máxima em metros
    }
  }
});

Consulta com Polígonos:

Você também pode realizar consultas dentro de áreas definidas usando polígonos. Vamos realizar uma consulta para encontrar todos os locais dentro de um polígono específico. Suponha que o polígono seja definido pelas seguintes coordenadas:

const poligono = [
  [-43.200, -22.920],
  [-43.200, -22.900],
  [-43.180, -22.900],
  [-43.180, -22.920],
  [-43.200, -22.920]
];

A consulta no MongoDB ficará assim:

db.locations.find({
  location: {
    $geoWithin: {
      $geometry: {
        type: "Polygon",
        coordinates: [poligono]
      }
    }
  }
});

Consulta com LineString

A consulta LineString no MongoDB é uma operação que permite encontrar documentos em uma coleção cujos dados geoespaciais, representados como trajetos contínuos (linhas), intersectam com uma linha específica. É útil para identificar, por exemplo, trajetos que passam por uma determinada rota ou área.

Para realizar essa consulta, utiliza-se o operador $geoIntersects em combinação com o tipo de dado LineString e as coordenadas da linha desejada no formato GeoJSON. Essa funcionalidade é valiosa em aplicações que envolvem análise de trajetos, rotas ou qualquer cenário onde a interseção de linhas geoespaciais seja relevante.

Exemplo prático de uso do LineString

Suponha que você tenha uma coleção chamada "rotas" que armazena informações sobre diferentes trajetos, cada um representado por um documento com um campo "path" no formato GeoJSON. Vamos criar um exemplo inserindo alguns dados e realizar uma consulta para encontrar rotas que intersectam com uma linha específica.

Inserindo dados de exemplo

Vamos inserir alguns dados de exemplo, representando as rotas:

db.rotas.insert({
  nome: "Rota A",
  path: {
    type: "LineString",
    coordinates: [
      [-43.200, -22.910],
      [-43.190, -22.905],
      [-43.180, -22.900]
    ]
  }
});

db.rotas.insert({
  nome: "Rota B",
  path: {
    type: "LineString",
    coordinates: [
      [-43.185, -22.915],
      [-43.175, -22.910],
      [-43.165, -22.905]
    ]
  }
});

// Insira outras rotas conforme necessário

Efetuando a consulta com LineString

Agora, vamos realizar uma consulta para encontrar rotas que intersectam com uma linha específica. Suponha que a linha seja definida pelas seguintes coordenadas:

const linha = [
  [-43.195, -22.912],
  [-43.185, -22.907],
  [-43.175, -22.902]
];

A consulta no MongoDB ficará assim:

db.rotas.find({
  path: {
    $geoIntersects: {
      $geometry: {
        type: "LineString",
        coordinates: linha
      }
    }
  }
});

Resumo

Os dados geoespaciais no MongoDB são um recurso poderoso para lidar com informações baseadas em localização. Eles são benéficos em cenários nos quais compreender e utilizar relacionamentos espaciais aprimoram a funcionalidade e eficiência do seu aplicativo.