Interroger des données relationnelles avec ParseSwift SDK

13min
Requêtes relationnelles
Introduction
Dans le guide précédent nous avons détaillé comment nous pouvons effectuer diverses requêtes sur une base de données Back4App. Dans ce guide, nous nous concentrons sur un type spécifique de requête qui implique des objets avec des relations.
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
Interroger des données relationnelles stockées sur une base de données Back4App en utilisant le ParseSwift SDK.
- Revue rapide de la classe Query<U>
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 une base de données Back4App
Avant de commencer à exécuter des requêtes, il est nécessaire de configurer certaines données sur une base de données Back4App. Nous allons stocker cinq types d'objets:
Author
Book
ISBD
Publisher
BookStore
 struct Author: ParseObject {
   ...
   var name: String?
 }
 struct Author: ParseObject {
   ...
   var name: String?
 }
﻿
De plus, afin de construire des requêtes pour des données relationnelles, nous allons mettre en œuvre les relations suivantes
1 relation entre Livre et ISBD.
N relation entre Livre et Éditeur.
M:N relation entre Livre et Auteur.
M:N relation entre Librairie et Livre.
Nous allons maintenant stocker des données dans la base de données Back4App. Cette étape peut être mise en œuvre en utilisant Swift ou directement depuis la console de votre application 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
 // Authors
 const aaronWriter = new Parse.Object('Author');
 aaronWriter.set('name', 'Aaron Writer');
 await aaronWriter.save();
5
 const beatriceNovelist = new Parse.Object('Author');
 beatriceNovelist.set('name', 'Beatrice Novelist');
 await beatriceNovelist.save();
9
const caseyColumnist = new Parse.Object('Author');
caseyColumnist.set('name', 'Casey Columnist');
await caseyColumnist.save();
13
// Publishers
const acaciaPublishings = new Parse.Object('Publisher');
acaciaPublishings.set('name', 'Acacia Publishings');
await acaciaPublishings.save();
18
const birchDistributions = new Parse.Object('Publisher');
birchDistributions.set('name', 'Birch Distributions');
await birchDistributions.save();
22
// Books with their corresponding ISBD
const aLoveStoryISBD = new Parse.Object('ISBD');
aLoveStoryISBD.set('isbn', '9781401211868');
await aLoveStoryISBD.save();
27
const aLoveStoryBook = new Parse.Object('Book');
aLoveStoryBook.set('title', 'A Love Story');
aLoveStoryBook.set('publisher', acaciaPublishings);
aLoveStoryBook.set('publishingDate', new Date('05/07/1998'));
aLoveStoryBook.set('isbd', aLoveStoryISBD);
const bookARelation = aLoveStoryBook.relation("authors");
bookARelation.add(aaronWriter);
await aLoveStoryBook.save();
aLoveStoryISBD.set('book', aLoveStoryBook.toPointer());
await aLoveStoryISBD.save();
38
const benevolentElvesISBD = new Parse.Object('ISBD');
benevolentElvesISBD.set('isbn', '9781401211868');
await benevolentElvesISBD.save();
42
const benevolentElvesBook = new Parse.Object('Book');
benevolentElvesBook.set('title', 'Benevolent Elves');
benevolentElvesBook.set('publisher', birchDistributions);
benevolentElvesBook.set('publishingDate', new Date('11/31/2008'));
benevolentElvesBook.set('isbd', benevolentElvesISBD);
const bookBRelation = benevolentElvesBook.relation("authors");
bookBRelation.add(beatriceNovelist);
await benevolentElvesBook.save();
benevolentElvesISBD.set('book', benevolentElvesBook.toPointer());
await benevolentElvesISBD.save();

const canYouBelieveItISBD = new Parse.Object('ISBD');
canYouBelieveItISBD.set('isbn', '9781401211868');
await canYouBelieveItISBD.save();
57
const canYouBelieveItBook = new Parse.Object('Book');
canYouBelieveItBook.set('title', 'Can You Believe It?');
canYouBelieveItBook.set('publisher', birchDistributions);
canYouBelieveItBook.set('publishingDate', new Date('08/21/2018'));
canYouBelieveItBook.set('isbd', canYouBelieveItISBD);
const bookCRelation = canYouBelieveItBook.relation("authors");
bookCRelation.add(aaronWriter);
bookCRelation.add(caseyColumnist);
await canYouBelieveItBook.save();
canYouBelieveItISBD.set('book', canYouBelieveItBook.toPointer());
await canYouBelieveItISBD.save();
69
// Book store
const booksOfLoveStore = new Parse.Object('BookStore');
booksOfLoveStore.set('name', 'Books of Love');
const bookStoreARelation = booksOfLoveStore.relation("books");
bookStoreARelation.add(aLoveStoryBook);
await booksOfLoveStore.save();
76
const fantasyBooksStore = new Parse.Object('BookStore');
fantasyBooksStore.set('name', 'Fantasy Books');
const bookStoreBRelation = fantasyBooksStore.relation("books");
bookStoreBRelation.add(benevolentElvesBook);
await fantasyBooksStore.save();
82
const generalBooksStore = new Parse.Object('BookStore');
generalBooksStore.set('name', 'General Books');
const bookStoreCRelation = generalBooksStore.relation("books");
bookStoreCRelation.add(aLoveStoryBook);
bookStoreCRelation.add(canYouBelieveItBook);
await generalBooksStore.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
 // Authors
 const aaronWriter = new Parse.Object('Author');
 aaronWriter.set('name', 'Aaron Writer');
 await aaronWriter.save();
5
 const beatriceNovelist = new Parse.Object('Author');
 beatriceNovelist.set('name', 'Beatrice Novelist');
 await beatriceNovelist.save();
9
const caseyColumnist = new Parse.Object('Author');
caseyColumnist.set('name', 'Casey Columnist');
await caseyColumnist.save();
13
// Publishers
const acaciaPublishings = new Parse.Object('Publisher');
acaciaPublishings.set('name', 'Acacia Publishings');
await acaciaPublishings.save();
18
const birchDistributions = new Parse.Object('Publisher');
birchDistributions.set('name', 'Birch Distributions');
await birchDistributions.save();
22
// Books with their corresponding ISBD
const aLoveStoryISBD = new Parse.Object('ISBD');
aLoveStoryISBD.set('isbn', '9781401211868');
await aLoveStoryISBD.save();
27
const aLoveStoryBook = new Parse.Object('Book');
aLoveStoryBook.set('title', 'A Love Story');
aLoveStoryBook.set('publisher', acaciaPublishings);
aLoveStoryBook.set('publishingDate', new Date('05/07/1998'));
aLoveStoryBook.set('isbd', aLoveStoryISBD);
const bookARelation = aLoveStoryBook.relation("authors");
bookARelation.add(aaronWriter);
await aLoveStoryBook.save();
aLoveStoryISBD.set('book', aLoveStoryBook.toPointer());
await aLoveStoryISBD.save();
38
const benevolentElvesISBD = new Parse.Object('ISBD');
benevolentElvesISBD.set('isbn', '9781401211868');
await benevolentElvesISBD.save();
42
const benevolentElvesBook = new Parse.Object('Book');
benevolentElvesBook.set('title', 'Benevolent Elves');
benevolentElvesBook.set('publisher', birchDistributions);
benevolentElvesBook.set('publishingDate', new Date('11/31/2008'));
benevolentElvesBook.set('isbd', benevolentElvesISBD);
const bookBRelation = benevolentElvesBook.relation("authors");
bookBRelation.add(beatriceNovelist);
await benevolentElvesBook.save();
benevolentElvesISBD.set('book', benevolentElvesBook.toPointer());
await benevolentElvesISBD.save();

const canYouBelieveItISBD = new Parse.Object('ISBD');
canYouBelieveItISBD.set('isbn', '9781401211868');
await canYouBelieveItISBD.save();
57
const canYouBelieveItBook = new Parse.Object('Book');
canYouBelieveItBook.set('title', 'Can You Believe It?');
canYouBelieveItBook.set('publisher', birchDistributions);
canYouBelieveItBook.set('publishingDate', new Date('08/21/2018'));
canYouBelieveItBook.set('isbd', canYouBelieveItISBD);
const bookCRelation = canYouBelieveItBook.relation("authors");
bookCRelation.add(aaronWriter);
bookCRelation.add(caseyColumnist);
await canYouBelieveItBook.save();
canYouBelieveItISBD.set('book', canYouBelieveItBook.toPointer());
await canYouBelieveItISBD.save();
69
// Book store
const booksOfLoveStore = new Parse.Object('BookStore');
booksOfLoveStore.set('name', 'Books of Love');
const bookStoreARelation = booksOfLoveStore.relation("books");
bookStoreARelation.add(aLoveStoryBook);
await booksOfLoveStore.save();
76
const fantasyBooksStore = new Parse.Object('BookStore');
fantasyBooksStore.set('name', 'Fantasy Books');
const bookStoreBRelation = fantasyBooksStore.relation("books");
bookStoreBRelation.add(benevolentElvesBook);
await fantasyBooksStore.save();
82
const generalBooksStore = new Parse.Object('BookStore');
generalBooksStore.set('name', 'General Books');
const bookStoreCRelation = generalBooksStore.relation("books");
bookStoreCRelation.add(aLoveStoryBook);
bookStoreCRelation.add(canYouBelieveItBook);
await generalBooksStore.save();
﻿
- Interroger les données
Une fois que la base de données a quelques données d'exemple avec lesquelles travailler, nous commençons à exécuter les différents types de requêtes associées aux relations détaillées précédemment.
Requêtes impliquant des relations 1:1
Étant donné deux types de données partageant une 1:1 relation (Livre et ISBD dans ce cas), nous pouvons récupérer l'un à partir de l'autre comme suit. La façon dont nous avons implémenté la relation dans Livre nous permet de récupérer son ISBD associé simplement en appelant la méthode include(_:) sur la requête. Récupérons le ISBD du livre Une histoire d'amour:
Swift
 let aLoveStoryBookQuery = Book.query("title" == "A Love Story").include("isbd") // Note how we include the ISBD with the include(_:) method
2
 let book = try? aLoveStoryBookQuery.first() // Retrieves synchronously the book including its ISBD
4
 aLoveStoryBookQuery.first { result in // Retrieves asynchronously the book including its ISBD
   // Handle the result (of type Result<Book, ParseError>)
 }
 let aLoveStoryBookQuery = Book.query("title" == "A Love Story").include("isbd") // Note how we include the ISBD with the include(_:) method
2
 let book = try? aLoveStoryBookQuery.first() // Retrieves synchronously the book including its ISBD
4
 aLoveStoryBookQuery.first { result in // Retrieves asynchronously the book including its ISBD
   // Handle the result (of type Result<Book, ParseError>)
 }
﻿
D'autre part, une requête pour récupérer un Livre associé à un ISBD donné est implémentée de la manière suivante. En regardant l'implémentation de ISBD, nous notons que la relation est représentée par la propriété livre (de type Pointer<livre>). Ce pointeur fournit un ensemble de méthodes et de propriétés pour récupérer des informations sur l'objet auquel il pointe. En particulier, nous appelons la méthode fetch(...) sur la propriété livre pour récupérer le Livre﻿
Swift
 let someISBD: ISBD
2
 let book: Book? = try? someISBD.book?.fetch() // Retrieves synchronously the book asscociated to someISBD
4
 someISBD.book?.fetch { result in // Retrieves asynchronously the book asscociated to someISBD
   // Handle the result (of type Result<Book, ParseError>)
 }
 let someISBD: ISBD
2
 let book: Book? = try? someISBD.book?.fetch() // Retrieves synchronously the book asscociated to someISBD
4
 someISBD.book?.fetch { result in // Retrieves asynchronously the book asscociated to someISBD
   // Handle the result (of type Result<Book, ParseError>)
 }
﻿
Nous devrions remarquer que cette implémentation pour une 1:1 relation n'est pas unique. Selon votre cas d'utilisation, vous pouvez implémenter des 1:1 relations de différentes manières.
Requêtes impliquant des relations 1:N
Dans un scénario où nous devons interroger tous les livres publiés par un éditeur donné, nous devons d'abord récupérer l'éditeur. Par exemple, nous récupérons d'abord l'objet de données associé à l'éditeur Acacia Publishings. Selon la situation, ce processus peut varier.
Swift
 do {
   // Using the object's objectId
   let acaciaPublishings = try Publisher(objectId: "SOME_OBJECT_ID").fetch()
4
   // Or
   // Using a Query
   let acaciaPublishings = try Publisher.query("name" == "Acacia Publishings").first() // Returns (synchronously) the first Publisher with name 'Acacia Publishings'. The constraint is constructed using the == operator provided by the ParseSwift SDK

   ... // To be completed below
} catch {
// Hanlde the error (of type ParseError)
}
 do {
   // Using the object's objectId
   let acaciaPublishings = try Publisher(objectId: "SOME_OBJECT_ID").fetch()
4
   // Or
   // Using a Query
   let acaciaPublishings = try Publisher.query("name" == "Acacia Publishings").first() // Returns (synchronously) the first Publisher with name 'Acacia Publishings'. The constraint is constructed using the == operator provided by the ParseSwift SDK

   ... // To be completed below
} catch {
// Hanlde the error (of type ParseError)
}
﻿
Maintenant que nous avons accès à acaciaPublishings, nous pouvons construire la requête pour récupérer ses livres associés. Nous procédons à créer la requête en instanciant une Query<Book> classe. Dans ce cas, cette classe est instanciée en utilisant la méthode statique query(...) fournie par l'objet Book. Les arguments (variadiques) pour cette méthode sont les objets standard QueryConstraint . Par conséquent, les livres que nous recherchons sont récupérés avec le snippet suivant.
Swift
 do {
   let acaciaPublishings = try Publisher.query("name" == "Acacia Publishings").first() // Returns the first Publisher with name 'Acacia Publishings'
3
   let constraint: QueryConstraint = try "publisher" == publisher
   let query = Book.query(constraint) // Creates the query to retrieve all Book objects where its publisher field equalt to 'acaciaPublishings'
6
   let books: [Book] = try query.find() // Executes the query synchronously
8
   // books should contain only one element: the book 'A Love Story'
} catch {
  // Hanlde the error (of type ParseError)
}
 do {
   let acaciaPublishings = try Publisher.query("name" == "Acacia Publishings").first() // Returns the first Publisher with name 'Acacia Publishings'
3
   let constraint: QueryConstraint = try "publisher" == publisher
   let query = Book.query(constraint) // Creates the query to retrieve all Book objects where its publisher field equalt to 'acaciaPublishings'
6
   let books: [Book] = try query.find() // Executes the query synchronously
8
   // books should contain only one element: the book 'A Love Story'
} catch {
  // Hanlde the error (of type ParseError)
}
﻿
Une implémentation asynchrone pour le snippet ci-dessus peut être écrite de la manière suivante
Swift
 // We retrieve the Publisher with name 'Acacia Publishings'
 Publisher.query("name" == "Acacia Publishings").first { result in
   switch result {
   case .success(let publisher):
     guard let constraint: QueryConstraint = try? "publisher" == publisher else { fatalError() }
6
     // Then, we retrieve the books with the corresponding constraint          
     Book.query(constraint).find { result in
       switch result {
      case .success(let books):
        // books should contain only one element: the book 'A Love Story'
        break
      case .failure(let error):
        // handle the error (of type ParseError)
        break
      }
    }
18
  case .failure(let error):
    // handle the error (of type ParseError)
    break
  }
}
 // We retrieve the Publisher with name 'Acacia Publishings'
 Publisher.query("name" == "Acacia Publishings").first { result in
   switch result {
   case .success(let publisher):
     guard let constraint: QueryConstraint = try? "publisher" == publisher else { fatalError() }
6
     // Then, we retrieve the books with the corresponding constraint          
     Book.query(constraint).find { result in
       switch result {
      case .success(let books):
        // books should contain only one element: the book 'A Love Story'
        break
      case .failure(let error):
        // handle the error (of type ParseError)
        break
      }
    }
18
  case .failure(let error):
    // handle the error (of type ParseError)
    break
  }
}
﻿
Requêtes impliquant des relations M:N (Cas 1)
Pour illustrer ce cas, nous considérons le scénario suivant ; nous voulons lister tous les magasins contenant des livres publiés après une date donnée (par exemple, 01/01/2010). Tout d'abord, nous avons besoin d'une requête intermédiaire pour sélectionner les livres. Ensuite, nous construisons la requête principale pour lister les magasins.
Par conséquent, nous préparons la première requête pour les livres
Swift
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
      
 do {
   let books = try booksQuery.find()
   ... // To be completed below
 } catch let error as ParseError {
   // Handle any potential error
 } catch {
   // Handle any potential error
}
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
      
 do {
   let books = try booksQuery.find()
   ... // To be completed below
 } catch let error as ParseError {
   // Handle any potential error
 } catch {
   // Handle any potential error
}
﻿
Nous construisons ensuite la requête des magasins en utilisant les résultats de booksQuery. La méthode containedIn(_:array:) retourne la contrainte dont nous avons besoin pour ce cas
Swift
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
      
 do {
   let books = try booksQuery.find()

   // Here is where we construct the stores' query with the corresponding constraint
   let storesQuery = BookStore.query(try containedIn(key: "books", array: books))
  
   let stores = try storesQuery.find()
  
  // stores should containt only one element: the 'General Books' BookStore 
} catch let error as ParseError {
  // Handle any potential error
} catch {
  // Handle any potential error
}
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
      
 do {
   let books = try booksQuery.find()

   // Here is where we construct the stores' query with the corresponding constraint
   let storesQuery = BookStore.query(try containedIn(key: "books", array: books))
  
   let stores = try storesQuery.find()
  
  // stores should containt only one element: the 'General Books' BookStore 
} catch let error as ParseError {
  // Handle any potential error
} catch {
  // Handle any potential error
}
﻿
De même, nous pouvons mettre en œuvre ce processus de manière asynchrone
Swift
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
2
 booksQuery.find { result in
   switch result {
   case .success(let books):
     guard let constraint = try? containedIn(key: "books", array: books) else { fatalError() }
     let storesQuery = BookStore.query(constraint)
              
     storesQuery.find { result in
      switch result {
      case .success(let stores):
      
      case .failure(let error):
        // Handle the error (of type ParseError)
      }
    }
  case .failure(let error):
    // Handle the error (of type ParseError)
  }
}
 let booksQuery = Book.query("publishingDate" > Date(string: "01/01/2010")) // We construct the date constraint using the > operator provided by the ParseSwift SDK
2
 booksQuery.find { result in
   switch result {
   case .success(let books):
     guard let constraint = try? containedIn(key: "books", array: books) else { fatalError() }
     let storesQuery = BookStore.query(constraint)
              
     storesQuery.find { result in
      switch result {
      case .success(let stores):
      
      case .failure(let error):
        // Handle the error (of type ParseError)
      }
    }
  case .failure(let error):
    // Handle the error (of type ParseError)
  }
}
﻿
Requêtes impliquant des relations M:N (Cas 2)
Supposons que nous devons sélectionner tous les magasins qui ont des livres écrits par un auteur donné, disons, Aaron Writer. Pour y parvenir, nous avons besoin de deux requêtes supplémentaires :
Une requête (Query<Author>) pour obtenir l'objet associé à l'auteur Aaron Writer.
Une requête (Query<Book>) pour sélectionner tous les livres écrits par Aaron Writer.
La requête principale (Query<BookStore>) pour sélectionner les magasins que nous recherchons.
La procédure pour mettre en œuvre ces requêtes est très similaire à celles précédentes :
Swift
 let authorQuery = Author.query("name" == "Aaron Writer") // The first query to retrieve the data object associated to 'Aaron Writer'
2
 do {
   let aaronWriter = try authorQuery.first()
          
   let booksQuery = Book.query(try containedIn(key: "authors", array: [aaronWriter])) // The second query to retrieve the books written by 'Aaron Writer'
          
   let books = try booksQuery.find()
          
  let storesQuery = BookStore.query(try containedIn(key: "books", array: books)) // The main query to select the stores where the author ('Aaron Writer') has his books available

  let stores = try storesQuery.find()
          
  // stores should contain two items: 'Books of Love' and 'General Books'
} catch let error as ParseError {
  // Handle the error
} catch {
  // Handle the error
}
 let authorQuery = Author.query("name" == "Aaron Writer") // The first query to retrieve the data object associated to 'Aaron Writer'
2
 do {
   let aaronWriter = try authorQuery.first()
          
   let booksQuery = Book.query(try containedIn(key: "authors", array: [aaronWriter])) // The second query to retrieve the books written by 'Aaron Writer'
          
   let books = try booksQuery.find()
          
  let storesQuery = BookStore.query(try containedIn(key: "books", array: books)) // The main query to select the stores where the author ('Aaron Writer') has his books available

  let stores = try storesQuery.find()
          
  // stores should contain two items: 'Books of Love' and 'General Books'
} catch let error as ParseError {
  // Handle the error
} catch {
  // Handle the error
}
﻿
Conclusion
Avec le ParseSwift SDK, nous avons pu construire des requêtes relationnelles qui nous ont permis de sélectionner des éléments en fonction du type de relations qu'ils ont avec d'autres types de données.
Mis à jour 27 Jan 2025
Cette page vous a-t-elle aidée?
Livre de recettes: Optimiser les requêtes ParseSwift
Optimisation des Geoqueries avec ParseSwift SDK pour iOS
Interroger des données relationnelles avec ParseSwift SDK

Requêtes relationnelles

Introduction

Prérequis

Objectif

1 - Revue rapide de la classe Query<U>

2 - Enregistrer des données sur une base de données Back4App

3 - Interroger les données

Conclusion
