Optimisation des Geoqueries avec ParseSwift SDK pour iOS

9min
Geoqueries
Introduction
Nous utilisons le terme Geoqueries pour désigner le type de requêtes dont les conditions impliquent des champs de type ParseGeoPoint. Il est recommandé d'utiliser la structure ParseGeoPoint pour stocker des données de localisation géographique dans une base de données Back4App. Le ParseSwift SDK fournit un ensemble de méthodes qui nous permet de requêter des données selon des conditions appliquées sur des données de type ParseGeoPoint.
Prérequis
Pour compléter ce tutoriel, vous aurez besoin de :
Une application créée sur Back4App.
Une application iOS de base pour tester les requêtes
Objectif
Comprendre comment requêter des données en utilisant des conditions sur des données de localisation géographique.
- Revue rapide sur la Query<U> classe
Toute requête effectuée sur une base de données Back4App se fait via la classe générique Query<U>. Le paramètre générique U (conforme au ParseObject protocole) est le type de données des objets que nous essayons de récupérer de la base de données.
Étant donné un type de données comme MyObject, nous récupérons ces objets d'une base de données Back4App de la manière suivante
Swift
 import ParseSwift
2
 struct MyObject: ParseObject {
   ...
 }
6
 let query = MyObject.query()
8
 // Executes the query asynchronously
query.find { result in
  // Handle the result (of type Result<[MyObject], ParseError>)
}
 import ParseSwift
2
 struct MyObject: ParseObject {
   ...
 }
6
 let query = MyObject.query()
8
 // Executes the query asynchronously
query.find { result in
  // Handle the result (of type Result<[MyObject], ParseError>)
}
﻿
Vous pouvez en savoir plus sur la Query<U> classe ici dans la documentation officielle.
- Enregistrer des données sur Back4App
Avant de commencer à exécuter des requêtes, nous devrions stocker quelques données d'exemple sur une base de données Back4App. En suivant le guide de démarrage rapide, vous pouvez configurer et lier votre application iOS d'exemple à votre base de données Back4App. Pour ce guide, nous allons stocker des informations sur les villes. Nous utilisons la structure suivante pour organiser les informations d'une ville :
Swift
 import ParseSwift
2
 struct City: ParseObject {
     ...
  
     var name: String? // City's name
     var location: ParseGeoPoint? // It will store the city's coordinate on Earth
 }
 import ParseSwift
2
 struct City: ParseObject {
     ...
  
     var name: String? // City's name
     var location: ParseGeoPoint? // It will store the city's coordinate on Earth
 }
﻿
Maintenant, nous procédons à stocker les données d'échantillon. Cette étape peut être mise en œuvre en utilisant Swift ou directement depuis la console sur la plateforme Back4App. 
Swift
Back4App's console
//A quick way to insert elements on your Back4App Database is via the console located in your App’s API section. Once you are there, you can start running Javascript code to save the sample data
 // Add City objects and create table
 // Note how GeoPoints are created, passing latitude and longitude as arguments
 // Montevideo
 City = new Parse.Object('City');
 City.set('name', 'Montevideo - Uruguay');
 City.set('location', new Parse.GeoPoint(-34.85553195363169, -56.207280375137955));
 await City.save();
8
 // Brasília
City = new Parse.Object('City');
City.set('name', 'Brasília - Brazil');
City.set('location', new Parse.GeoPoint(-15.79485821477289, -47.88391074690196));
await City.save();
14
// Bogotá
City = new Parse.Object('City');
City.set('name', 'Bogotá - Colombia');
City.set('location', new Parse.GeoPoint(4.69139880891712, -74.06936691331047));
await City.save();
20
// Mexico City
City = new Parse.Object('City');
City.set('name', 'Mexico City - Mexico');
City.set('location', new Parse.GeoPoint(19.400977162618933, -99.13311378164776));
await City.save();
26
// Washington, D.C.
City = new Parse.Object('City');
City.set('name', 'Washington, D.C. - USA');
City.set('location', new Parse.GeoPoint(38.930727220189944, -77.04626261880388));
await City.save();
32
// Ottawa
City = new Parse.Object('City');
City.set('name', 'Ottawa - Canada');
City.set('location', new Parse.GeoPoint(45.41102167733425, -75.695414598736));
await City.save();
//A quick way to insert elements on your Back4App Database is via the console located in your App’s API section. Once you are there, you can start running Javascript code to save the sample data
 // Add City objects and create table
 // Note how GeoPoints are created, passing latitude and longitude as arguments
 // Montevideo
 City = new Parse.Object('City');
 City.set('name', 'Montevideo - Uruguay');
 City.set('location', new Parse.GeoPoint(-34.85553195363169, -56.207280375137955));
 await City.save();
8
 // Brasília
City = new Parse.Object('City');
City.set('name', 'Brasília - Brazil');
City.set('location', new Parse.GeoPoint(-15.79485821477289, -47.88391074690196));
await City.save();
14
// Bogotá
City = new Parse.Object('City');
City.set('name', 'Bogotá - Colombia');
City.set('location', new Parse.GeoPoint(4.69139880891712, -74.06936691331047));
await City.save();
20
// Mexico City
City = new Parse.Object('City');
City.set('name', 'Mexico City - Mexico');
City.set('location', new Parse.GeoPoint(19.400977162618933, -99.13311378164776));
await City.save();
26
// Washington, D.C.
City = new Parse.Object('City');
City.set('name', 'Washington, D.C. - USA');
City.set('location', new Parse.GeoPoint(38.930727220189944, -77.04626261880388));
await City.save();
32
// Ottawa
City = new Parse.Object('City');
City.set('name', 'Ottawa - Canada');
City.set('location', new Parse.GeoPoint(45.41102167733425, -75.695414598736));
await City.save();
﻿
- Interroger les données
Trier les résultats
Avec les données d'exemple sauvegardées, nous pouvons commencer à effectuer différents types de requêtes.
Pour notre premier exemple, nous allons sélectionner toutes les villes et les trier en fonction de leur distance par rapport à un point géographique de référence. Nous mettons en œuvre cette requête en passant une contrainte à l' Query<City> objet. La méthode near(key:geoPoint:) disponible via le ParseSwift SDK nous permet de construire une telle contrainte. Comme arguments, nous passons le nom du champ (généralement appelé key) contenant le geoPoint de référence.
Swift
 // The reference geopoint will be Kingston city - Jamaica
 guard let kingstonGeoPoint = try? ParseGeoPoint(latitude: 18.018086950599134, longitude: -76.79894232253473) else { return }
3
 let query = City.query(near(key: "location", geoPoint: kingstonGeoPoint)) // The method near(key:geoPoint:) returns the constraint needed to sort the query
5
 let sortedCities: [City]? = try? query.find() // Executes the query synchronosuly and returns an array containing the cities properly sorted
7
 query.find { result in // Executes the query asynchronosuly and returns a Result<[City], ParseError> type object to handle the results
   switch result {
  case .success(let cities):
    // cities = [Bogotá, Washington DC, Mexico City, Ottawa, Brasília, Montevideo]
  case .failure(let error):
    // Handle the error if something happened
  }
}
 // The reference geopoint will be Kingston city - Jamaica
 guard let kingstonGeoPoint = try? ParseGeoPoint(latitude: 18.018086950599134, longitude: -76.79894232253473) else { return }
3
 let query = City.query(near(key: "location", geoPoint: kingstonGeoPoint)) // The method near(key:geoPoint:) returns the constraint needed to sort the query
5
 let sortedCities: [City]? = try? query.find() // Executes the query synchronosuly and returns an array containing the cities properly sorted
7
 query.find { result in // Executes the query asynchronosuly and returns a Result<[City], ParseError> type object to handle the results
   switch result {
  case .success(let cities):
    // cities = [Bogotá, Washington DC, Mexico City, Ottawa, Brasília, Montevideo]
  case .failure(let error):
    // Handle the error if something happened
  }
}
﻿
Sélectionner des résultats dans une région donnée
Supposons que nous voulons sélectionner des villes dans une certaine région. Nous pouvons y parvenir avec une contrainte créée par la méthode withinKilometers(key:geoPoint:distance:). En arguments, nous passons le nom du champ contenant la localisation de la ville, le centre de la région (un ParseGeoPoint de type de données) et la distance maximale (en km) qu'une ville peut être de ce centre de région. Pour sélectionner toutes les villes qui sont à au plus 3000km de Kingston - Jamaïque, nous pouvons le faire de la manière suivante
Swift
 let distance: Double = 3000 // km
 guard let kingstonGeoPoint = try? ParseGeoPoint(latitude: 18.018086950599134, longitude: -76.79894232253473) else { return }
3
 let query = City.query(withinKilometers(key: "location", geoPoint: kingstonGeoPoint, distance: distance))
 // The method withinKilometers(key:geoPoint:distance:) returns the constraint we need for this case
6
 let sortedCities: [City]? = try? query.find() // Executes the query synchronosuly and returns an array containing the cities we are looking for (Bogotá, Washington DC and Mexico city in this case)
8
 query.find { result in // Executes the query asynchronosuly and returns a Result<[City], ParseError> type object to handle the results
  switch result {
  case .success(let cities):
    // cities = [Bogotá, Washington DC, Mexico City]
  case .failure(let error):
    // Handle the error if something happened
  }
}
 let distance: Double = 3000 // km
 guard let kingstonGeoPoint = try? ParseGeoPoint(latitude: 18.018086950599134, longitude: -76.79894232253473) else { return }
3
 let query = City.query(withinKilometers(key: "location", geoPoint: kingstonGeoPoint, distance: distance))
 // The method withinKilometers(key:geoPoint:distance:) returns the constraint we need for this case
6
 let sortedCities: [City]? = try? query.find() // Executes the query synchronosuly and returns an array containing the cities we are looking for (Bogotá, Washington DC and Mexico city in this case)
8
 query.find { result in // Executes the query asynchronosuly and returns a Result<[City], ParseError> type object to handle the results
  switch result {
  case .success(let cities):
    // cities = [Bogotá, Washington DC, Mexico City]
  case .failure(let error):
    // Handle the error if something happened
  }
}
﻿
De plus, lorsque la distance est donnée en miles au lieu de kilomètres, nous pouvons utiliser le withinMiles(key:geoPoint:distance:sorted:) méthode.
Une méthode moins courante, withinRadians(key:geoPoint:distance:sorted:), est également disponible si la distance est donnée en radians. Son utilisation est très similaire aux méthodes précédentes.
Sélectionner des résultats dans un polygone donné
Dans l'exemple précédent, nous avons sélectionné des villes dans une région représentée par une région circulaire. Dans le cas où nous devons avoir une forme non circulaire pour la région, le ParseSwift SDK nous permet de construire de telles régions à partir de leurs sommets.
Maintenant, l'objectif de cet exemple est de sélectionner des villes à l'intérieur d'un polygone à cinq sommets. Ces sommets sont exprimés en utilisant le ParseGeoPoint struct. Une fois que nous avons créé les sommets, nous instancions un ParsePolygon. Ce polygone est ensuite passé à la withinPolygon(key:polygon:) méthode (fournie par le ParseSwift SDK) pour construire la contrainte qui nous permettra de sélectionner des villes à l'intérieur de ce polygone.
Swift
 // The polygon where the selected cities are
 let polygon: ParsePolygon? = {
   do {
     // We first instantiate the polygon vertices
     let geoPoint1 = try ParseGeoPoint(latitude: 15.822238344514378, longitude: -72.42845934415942)
     let geoPoint2 = try ParseGeoPoint(latitude: -0.7433770196268968, longitude: -97.44765968406668)
     let geoPoint3 = try ParseGeoPoint(latitude: -59.997149373299166, longitude: -76.52969196322749)
     let geoPoint4 = try ParseGeoPoint(latitude: -9.488786415007201, longitude: -18.346101586021952)
     let geoPoint5 = try ParseGeoPoint(latitude: 15.414859532811047, longitude: -60.00625459569375)
              
    // Next we compose the polygon
    return try ParsePolygon([geoPoint1, geoPoint2, geoPoint3, geoPoint4, geoPoint5])
  } catch let error as ParseError {
    print("Failed to instantiate vertices: \(error.message)")
    return nil
  } catch {
    print("Failed to instantiate vertices: \(error.localizedDescription)")
    return nil
  }
}()
      
guard let safePolygon = polygon else { return }
      
let query = City.query(withinPolygon(key: "location", polygon: safePolygon))
// withinPolygon(key:polygon:) returns the required constraint to apply on the query
      
let cities = try? query.find() // Executes the query synchronously
      
query.find { result in // Executes the query asynchronously and returns a result of type Result<[], ParseError>
  // Handle the result
}
 // The polygon where the selected cities are
 let polygon: ParsePolygon? = {
   do {
     // We first instantiate the polygon vertices
     let geoPoint1 = try ParseGeoPoint(latitude: 15.822238344514378, longitude: -72.42845934415942)
     let geoPoint2 = try ParseGeoPoint(latitude: -0.7433770196268968, longitude: -97.44765968406668)
     let geoPoint3 = try ParseGeoPoint(latitude: -59.997149373299166, longitude: -76.52969196322749)
     let geoPoint4 = try ParseGeoPoint(latitude: -9.488786415007201, longitude: -18.346101586021952)
     let geoPoint5 = try ParseGeoPoint(latitude: 15.414859532811047, longitude: -60.00625459569375)
              
    // Next we compose the polygon
    return try ParsePolygon([geoPoint1, geoPoint2, geoPoint3, geoPoint4, geoPoint5])
  } catch let error as ParseError {
    print("Failed to instantiate vertices: \(error.message)")
    return nil
  } catch {
    print("Failed to instantiate vertices: \(error.localizedDescription)")
    return nil
  }
}()
      
guard let safePolygon = polygon else { return }
      
let query = City.query(withinPolygon(key: "location", polygon: safePolygon))
// withinPolygon(key:polygon:) returns the required constraint to apply on the query
      
let cities = try? query.find() // Executes the query synchronously
      
query.find { result in // Executes the query asynchronously and returns a result of type Result<[], ParseError>
  // Handle the result
}
﻿
Conclusion
De nos jours, effectuer des opérations sur des données de localisation pour offrir des services personnalisés est très important. Back4App, avec le ParseSwift SDK facilite la mise en œuvre de ce type d'opérations.
Mis à jour 27 Jan 2025
Cette page vous a-t-elle aidée?
Interroger des données relationnelles avec ParseSwift SDK
Inscription utilisateur avec ParseSwift SDK sur iOS
Optimisation des Geoqueries avec ParseSwift SDK pour iOS

Geoqueries

Introduction

Prérequis

Objectif

1 - Revue rapide sur la Query<U> classe

2 - Enregistrer des données sur Back4App

3 - Interroger les données

Conclusion
