Implémentation de relations avec Parse Swift SDK sur iOS

16min
Relations
Introduction
Les relations sont une caractéristique fondamentale pour organiser les objets de données stockés dans une base de données. ParseSwift fournit les outils et méthodes nécessaires pour établir des relations entre les classes dans votre base de données Back4App. En fonction du cas d'utilisation, nous pouvons identifier les types de relations suivants
1: Une relation qui ne connecte que deux objets de données.
N: Une relation entre un objet de données etN objets de données
N:N: Une relation entreN objets de données àN objets de données.
Comme nous le verrons ci-dessous, la mise en œuvre des relations 1:1 est relativement simple. Pour les relations 1:N et N:N , la mise en œuvre implique l'objet ParseRelation fourni par le ParseSwift SDK. Il existe des alternatives supplémentaires pour mettre en œuvre les relations 1:N et N:N. Cependant, en raison de l'efficacité et des performances, nous recommandons de suivre notre approche
Ce tutoriel utilise une application de base créée dans Xcode 12 et iOS 14.
À tout moment, vous pouvez accéder au projet complet via nos dépôts GitHub.
﻿Dépôt d'exemple iOS﻿
Objectif
Comprendre comment les relations sont mises en œuvre dans une base de données Back4App.
Prérequis
Pour compléter ce guide rapide, vous avez besoin de :
Xcode.
Une application créée sur Back4App.
Suivez le tutoriel sur la nouvelle application Parse pour apprendre à créer une application Parse sur Back4App.
Remarque : Suivez le tutoriel d'installation du SDK Parse (Swift) pour créer un projet Xcode connecté à Back4App.
Comprendre notre application de livres
Le modèle de projet est une application de livres où l'utilisateur saisit les détails d'un livre pour l'enregistrer dans une base de données Back4App. Sur l'écran d'accueil de l'application, vous trouverez le formulaire pour le faire.
﻿
En utilisant le + bouton situé en haut à droite de la barre de navigation, nous pouvons ajouter autant de Éditeurs, Genres et Auteurs que nécessaire. Une fois que l'utilisateur a saisi un livre, il peut utiliser le Ajouter un livre bouton pour enregistrer le livre dans sa base de données Back4App. De plus, le Lister les livres bouton nous permettra d'afficher tous les livres que l'utilisateur a ajoutés et également de voir leur relation avec les éditeurs et les auteurs.
Référence rapide des commandes que nous allons utiliser
Nous utilisons les objets Auteur, Éditeur, ISBN et Livre:
Genre
Author
Publisher
ISBN
Book
 import Foundation
 import ParseSwift
3
 struct Genre: ParseObject {
     ...
  
     var name: String?
  
     ...
}
 import Foundation
 import ParseSwift
3
 struct Genre: ParseObject {
     ...
  
     var name: String?
  
     ...
}
﻿
Avant de stocker des instances de ces objets dans une base de données Back4App, toutes leurs propriétés doivent se conformer aux Codable et Hashable protocoles.
Nous utilisons les méthodes suivantes pour gérer ces objets sur la base de données Back4App :
Create
Read
Add relations
Query relations
Remaining relations
   //When creating a new instance of Author we use
 var newAuthor: Author = Author(name: "John Doe")
2
 // Saves newAuthor on your Back4App Database synchronously and returns the new saved Item. It throws and error if something went wrong.
 let savedAuthor = try? newAuthor.save()
5
 // Saves newAuthor on your Back4App Database asynchronously, and passes a Result<Author, ParseError> object to the completion block to handle the save process.
 newAuthor.save { result in
     // Handle the result to check wether the save process was successfull or not
 }
   //When creating a new instance of Author we use
 var newAuthor: Author = Author(name: "John Doe")
2
 // Saves newAuthor on your Back4App Database synchronously and returns the new saved Item. It throws and error if something went wrong.
 let savedAuthor = try? newAuthor.save()
5
 // Saves newAuthor on your Back4App Database asynchronously, and passes a Result<Author, ParseError> object to the completion block to handle the save process.
 newAuthor.save { result in
     // Handle the result to check wether the save process was successfull or not
 }
﻿
- Téléchargez le modèle de l'application Books
Le XCode projet a la structure suivante
﻿
À tout moment, vous pouvez accéder au projet complet via nos dépôts GitHub.
﻿Dépôt d'exemple iOS﻿
- Flux CRUD supplémentaire

Avant d'aller plus loin, il est nécessaire d'implémenter quelques fonctions CRUD pour pouvoir sauvegarder les Auteurs, Éditeurs et Genres objets. Dans leMainController+ParseSwift.swift fichier, sous une extension pour la MainController classe, nous avons implémenté les méthodes suivantes
Swift
 // MainController+ParseSwift.swift file
 extension MainController {
     /// Collects the data to save an instance of Book on your Back4App database.
     func saveBook() {
         view.endEditing(true)
      
         // 1. First retrieve all the information for the Book (title, isbn, etc)
         guard let bookTitle = bookTitleTextField.text else {
             return presentAlert(title: "Error", message: "Invalid book title")
        }
      
        guard let isbnValue = isbnTextField.text else {
            return presentAlert(title: "Error", message: "Invalid ISBN value.")
        }
      
        let query = ISBN.query("value" == isbnValue)
      
        guard (try? query.first()) == nil else {
            return presentAlert(title: "Error", message: "The entered ISBN already exists.")
        }
        
        guard let genreObjectId = genreOptionsView.selectedOptionIds.first,
              let genre = genres.first(where: { $0.objectId == genreObjectId})
        else {
            return presentAlert(title: "Error", message: "Invalid genre.")
        }
      
        guard let publishingYearString = publishingYearTextField.text, let publishingYear = Int(publishingYearString) else {
            return presentAlert(title: "Error", message: "Invalid publishing year.")
        }
        
        let authors: [Author] = self.authorOptionsView.selectedOptionIds.compactMap { [weak self] objectId in
           self?.authors.first(where: { objectId == $0.objectId })
        }
      
        let publishers: [Publisher] = self.publisherOptionsView.selectedOptionIds.compactMap { [weak self] objectId in
           self?.publishers.first(where: { objectId == $0.objectId })
        }
      
        // Since we are making multiple requests to Back4App, it is better to use synchronous methods and dispatch them on the background queue
        DispatchQueue.global(qos: .background).async {
            do {
                let isbn = ISBN(value: isbnValue) // 2. Instantiate a new ISBN object
              
                let savedBook = try Book( // 3. Instantiate a new Book object with the corresponding input fields
                    title: bookTitle,
                   publishingYear: publishingYear,
                    genre: genre,
                    isbn: isbn
                ).save() // 4. Save the new Book object
              
                ... // Here we will implement the relations
                
                DispatchQueue.main.async {
                    self.presentAlert(title: "Success", message: "Book saved successfully.")
                }
            } catch {
                DispatchQueue.main.async {
                   self.presentAlert(title: "Error", message: "Failed to save book: \((error as! ParseError).message)")
                }
            }
        }
    }
  
    /// Retrieves all the data saved under the Genre class in your Back4App Database
    func fetchGenres() {
        let query = Genre.query()
        
        query.find { [weak self] result in
            switch result {
            case .success(let genres):
                self?.genres = genres // When setting self?.genres, it triggers the corresponding UI update
            case .failure(let error):
                self?.presentAlert(title: "Error", message: error.message)
            }
        }
    }
  
    /// Presents a simple alert where the user can enter the name of a genre to save it on your Back4App Database
    func handleAddGenre() {
        // Displays a form with a single input and executes the completion block when the user presses the submit button
        presentForm(
            title: "Add genre",
            description: "Enter a description for the genre",
            placeholder: nil
        ) { [weak self] name in
            guard let name = name else { return }
            let genre = Genre(name: name)
            
            let query = Genre.query("name" == name)
          
            guard ((try? query.first()) == nil) else {
                self?.presentAlert(title: "Error", message: "This genre already exists.")
                return
            }
            
            genre.save { [weak self] result in
                switch result {
                case .success(let addedGenre):
                   self?.presentAlert(title: "Success", message: "Genre added!")
                   self?.genres.append(addedGenre)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save genre: \(error.message)")
               }
           }
       }
   }
   
   /// Retrieves all the data saved under the Publisher class in your Back4App Database
   func fetchPublishers() {
       let query = Publisher.query()
       
       query.find { [weak self] result in
           switch result {
           case .success(let publishers):
               self?.publishers = publishers
           case .failure(let error):
               self?.presentAlert(title: "Error", message: error.message)
           }
       }
   }
  
   /// Presents a simple alert where the user can enter the name of a publisher to save it on your Back4App Database
   func handleAddPublisher() {
       // Displays a form with a single input and executes the completion block when the user presses the submit button
       presentForm(
           title: "Add publisher",
           description: "Enter the name of the publisher",
           placeholder: nil
       ) { [weak self] name in
           guard let name = name else { return }
           
           let query = Publisher.query("name" == name)
           
           guard ((try? query.first()) == nil) else {
               self?.presentAlert(title: "Error", message: "This publisher already exists.")
               return
           }
           
           let publisher = Publisher(name: name)
           
           publisher.save { [weak self] result in
               switch result {
               case .success(let addedPublisher):
                   self?.presentAlert(title: "Success", message: "Publisher added!")
                   self?.publishers.append(addedPublisher)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save publisher: \(error.message)")
               }
           }
       }
   }
  
   /// Retrieves all the data saved under the Genre class in your Back4App Database
   func fetchAuthors() {
       let query = Author.query()
      
       query.find { [weak self] result in
           switch result {
           case .success(let authors):
               self?.authors = authors
           case .failure(let error):
               self?.presentAlert(title: "Error", message: error.message)
           }
       }
   }
  
   /// Presents a simple alert where the user can enter the name of an author to save it on your Back4App Database
   func handleAddAuthor() {
       // Displays a form with a single input and executes the completion block when the user presses the submit button
       presentForm(
           title: "Add author",
           description: "Enter the name of the author",
           placeholder: nil
       ) { [weak self] name in
           guard let name = name else { return }
          
           let query = Author.query("name" == name)
          
           guard ((try? query.first()) == nil) else {
               self?.presentAlert(title: "Error", message: "This author already exists.")
               return
           }
           
           let author = Author(name: name)
           
           author.save { [weak self] result in
               switch result {
               case .success(let addedAuthor):
                   self?.presentAlert(title: "Success", message: "Author added!")
                   self?.authors.append(addedAuthor)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save author: \(error.message)")
               }
           }
       }
   }
}sw
 // MainController+ParseSwift.swift file
 extension MainController {
     /// Collects the data to save an instance of Book on your Back4App database.
     func saveBook() {
         view.endEditing(true)
      
         // 1. First retrieve all the information for the Book (title, isbn, etc)
         guard let bookTitle = bookTitleTextField.text else {
             return presentAlert(title: "Error", message: "Invalid book title")
        }
      
        guard let isbnValue = isbnTextField.text else {
            return presentAlert(title: "Error", message: "Invalid ISBN value.")
        }
      
        let query = ISBN.query("value" == isbnValue)
      
        guard (try? query.first()) == nil else {
            return presentAlert(title: "Error", message: "The entered ISBN already exists.")
        }
        
        guard let genreObjectId = genreOptionsView.selectedOptionIds.first,
              let genre = genres.first(where: { $0.objectId == genreObjectId})
        else {
            return presentAlert(title: "Error", message: "Invalid genre.")
        }
      
        guard let publishingYearString = publishingYearTextField.text, let publishingYear = Int(publishingYearString) else {
            return presentAlert(title: "Error", message: "Invalid publishing year.")
        }
        
        let authors: [Author] = self.authorOptionsView.selectedOptionIds.compactMap { [weak self] objectId in
           self?.authors.first(where: { objectId == $0.objectId })
        }
      
        let publishers: [Publisher] = self.publisherOptionsView.selectedOptionIds.compactMap { [weak self] objectId in
           self?.publishers.first(where: { objectId == $0.objectId })
        }
      
        // Since we are making multiple requests to Back4App, it is better to use synchronous methods and dispatch them on the background queue
        DispatchQueue.global(qos: .background).async {
            do {
                let isbn = ISBN(value: isbnValue) // 2. Instantiate a new ISBN object
              
                let savedBook = try Book( // 3. Instantiate a new Book object with the corresponding input fields
                    title: bookTitle,
                   publishingYear: publishingYear,
                    genre: genre,
                    isbn: isbn
                ).save() // 4. Save the new Book object
              
                ... // Here we will implement the relations
                
                DispatchQueue.main.async {
                    self.presentAlert(title: "Success", message: "Book saved successfully.")
                }
            } catch {
                DispatchQueue.main.async {
                   self.presentAlert(title: "Error", message: "Failed to save book: \((error as! ParseError).message)")
                }
            }
        }
    }
  
    /// Retrieves all the data saved under the Genre class in your Back4App Database
    func fetchGenres() {
        let query = Genre.query()
        
        query.find { [weak self] result in
            switch result {
            case .success(let genres):
                self?.genres = genres // When setting self?.genres, it triggers the corresponding UI update
            case .failure(let error):
                self?.presentAlert(title: "Error", message: error.message)
            }
        }
    }
  
    /// Presents a simple alert where the user can enter the name of a genre to save it on your Back4App Database
    func handleAddGenre() {
        // Displays a form with a single input and executes the completion block when the user presses the submit button
        presentForm(
            title: "Add genre",
            description: "Enter a description for the genre",
            placeholder: nil
        ) { [weak self] name in
            guard let name = name else { return }
            let genre = Genre(name: name)
            
            let query = Genre.query("name" == name)
          
            guard ((try? query.first()) == nil) else {
                self?.presentAlert(title: "Error", message: "This genre already exists.")
                return
            }
            
            genre.save { [weak self] result in
                switch result {
                case .success(let addedGenre):
                   self?.presentAlert(title: "Success", message: "Genre added!")
                   self?.genres.append(addedGenre)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save genre: \(error.message)")
               }
           }
       }
   }
   
   /// Retrieves all the data saved under the Publisher class in your Back4App Database
   func fetchPublishers() {
       let query = Publisher.query()
       
       query.find { [weak self] result in
           switch result {
           case .success(let publishers):
               self?.publishers = publishers
           case .failure(let error):
               self?.presentAlert(title: "Error", message: error.message)
           }
       }
   }
  
   /// Presents a simple alert where the user can enter the name of a publisher to save it on your Back4App Database
   func handleAddPublisher() {
       // Displays a form with a single input and executes the completion block when the user presses the submit button
       presentForm(
           title: "Add publisher",
           description: "Enter the name of the publisher",
           placeholder: nil
       ) { [weak self] name in
           guard let name = name else { return }
           
           let query = Publisher.query("name" == name)
           
           guard ((try? query.first()) == nil) else {
               self?.presentAlert(title: "Error", message: "This publisher already exists.")
               return
           }
           
           let publisher = Publisher(name: name)
           
           publisher.save { [weak self] result in
               switch result {
               case .success(let addedPublisher):
                   self?.presentAlert(title: "Success", message: "Publisher added!")
                   self?.publishers.append(addedPublisher)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save publisher: \(error.message)")
               }
           }
       }
   }
  
   /// Retrieves all the data saved under the Genre class in your Back4App Database
   func fetchAuthors() {
       let query = Author.query()
      
       query.find { [weak self] result in
           switch result {
           case .success(let authors):
               self?.authors = authors
           case .failure(let error):
               self?.presentAlert(title: "Error", message: error.message)
           }
       }
   }
  
   /// Presents a simple alert where the user can enter the name of an author to save it on your Back4App Database
   func handleAddAuthor() {
       // Displays a form with a single input and executes the completion block when the user presses the submit button
       presentForm(
           title: "Add author",
           description: "Enter the name of the author",
           placeholder: nil
       ) { [weak self] name in
           guard let name = name else { return }
          
           let query = Author.query("name" == name)
          
           guard ((try? query.first()) == nil) else {
               self?.presentAlert(title: "Error", message: "This author already exists.")
               return
           }
           
           let author = Author(name: name)
           
           author.save { [weak self] result in
               switch result {
               case .success(let addedAuthor):
                   self?.presentAlert(title: "Success", message: "Author added!")
                   self?.authors.append(addedAuthor)
               case .failure(let error):
                   self?.presentAlert(title: "Error", message: "Failed to save author: \(error.message)")
               }
           }
       }
   }
}sw
﻿
Pour plus de détails sur cette étape, vous pouvez consulter le guide des opérations de base.
- Configurer les relations
Avant de commencer à créer des relations, jetez un œil à la référence rapide section pour avoir une idée des objets que nous voulons relier entre eux. Dans la figure ci-dessous, nous montrons comment ces objets sont liés.
﻿
Comme on peut le voir, les relations sont créées en plaçant l'objet Livre au milieu. Les flèches montrent comment chaque objet est lié à un Livre.
- Mise en œuvre des relations
Cas 1:1
Ajouter des relations 1:1 peut être facilement réalisé en ajoutant une propriété dans l'objet Livre, c'est-à-dire,
Swift
 struct Book: ParseObject {
     ...
3
     var isbn: ISBN? // Esablishes a 1:1 relation between Book and ISBN
  
     ...
 }
 struct Book: ParseObject {
     ...
3
     var isbn: ISBN? // Esablishes a 1:1 relation between Book and ISBN
  
     ...
 }
﻿
Dans ce cas, Livre et ISBN partagent une relation 1:1 où Livre est identifié comme le parent et ISBN comme l'enfant. En interne, lorsque Back4App enregistre une instance de Livre, il enregistre d'abord l'objet ISBN (sous le nom de classe ISBN). Une fois ce processus terminé, Back4App continue avec l'objet Livre. Le nouvel objet Livre est enregistré de manière à ce que sa isbn soit représentée par un Pointer<ISBN> objet. Un Pointer<> permet de stocker une instance unique de l'objet ISBN liée à son parent correspondant.
Cas 1:N
Pour 1:N relations, la manière la plus efficace de les implémenter est via un ParseRelation<Book> objet. ParseSwift fournit un ensemble de méthodes pour ajouter ces types de relations pour tout objet conforme au ParseObject protocole. Par exemple, si nous voulons créer une 1:N relation entre Book et Author nous pouvons utiliser
Swift
 let someBook: Book
 let authors: [Author]
 ...
4
 // We create a relation (identified by the name 'authors') between someBook and a set of authors
 let bookToAuthorsRelation = 
 guard let bookToAuthorsRelation = try someBook.relation?.add("authors", objects: authors) // Book -> Author 
 else {
     fatalError("Failed to add relation")
}
11
let savedRelation = try bookToAuthorsRelation.save() // Saves the relation synchronously
13
bookToAuthorsRelation.save { result in // Saves the relation asynchronously
    // Handle the result
}
 let someBook: Book
 let authors: [Author]
 ...
4
 // We create a relation (identified by the name 'authors') between someBook and a set of authors
 let bookToAuthorsRelation = 
 guard let bookToAuthorsRelation = try someBook.relation?.add("authors", objects: authors) // Book -> Author 
 else {
     fatalError("Failed to add relation")
}
11
let savedRelation = try bookToAuthorsRelation.save() // Saves the relation synchronously
13
bookToAuthorsRelation.save { result in // Saves the relation asynchronously
    // Handle the result
}
﻿
Il est simple d'adapter ce extrait pour les autres relations que nous avons pour Livre.
- Mettre le tout ensemble
Une fois que nous avons établi l'idée de base pour implémenter les relations, nous complétons maintenant le saveBook() méthode. Nous énumérons les points clés à garder à l'esprit pendant ce processus
Swift
 extension MainController {
     /// Collects the data to save an instance of Book on your Back4App database.
     func saveBook() {
         ...        
         // 1. First retrieve all the information for the Book (bookTitle, isbnValue, etc)
         ...
7
         // Since we are making multiple requests to Back4App, it is better to use synchronous methods and dispatch them on the background queue
         DispatchQueue.global(qos: .background).async {
            do {
                let isbn = ISBN(value: isbnValue) // 2. Instantiate a new ISBN object
              
                let savedBook = try Book( // 3. Instantiate a new Book object with the corresponding input fields
                    title: bookTitle,
                    publishingYear: publishingYear,
                    genre: genre,
                    isbn: isbn
                ).save() // 4. Save the new Book object
              
                // 5. Add the corresponding relations for new Book object
                guard let bookToAuthorsRelation = try savedBook.relation?.add("authors", objects: authors), // Book -> Author
                      let bootkToPublishersRelation = try savedBook.relation?.add("publishers", objects: publishers), // Book -> Publisher
                      let genreRelation = try genre.relation?.add("books", objects: [savedBook]) // Genre -> Book
                else {
                    return DispatchQueue.main.async {
                        self.presentAlert(title: "Error", message: "Failed to add relations")
                    }
                }
                               
                // 6. Save the relations
                _ = try bookToAuthorsRelation.save()
                _ = try bootkToPublishersRelation.save()
                _ = try genreRelation.save()
               
                DispatchQueue.main.async {
                    self.presentAlert(title: "Success", message: "Book saved successfully.")
                }
            } catch {
                DispatchQueue.main.async {
                    self.presentAlert(title: "Error", message: "Failed to save book: \((error as! ParseError).message)")
                }
            }
        }
    }
45
    ...
}
 extension MainController {
     /// Collects the data to save an instance of Book on your Back4App database.
     func saveBook() {
         ...        
         // 1. First retrieve all the information for the Book (bookTitle, isbnValue, etc)
         ...
7
         // Since we are making multiple requests to Back4App, it is better to use synchronous methods and dispatch them on the background queue
         DispatchQueue.global(qos: .background).async {
            do {
                let isbn = ISBN(value: isbnValue) // 2. Instantiate a new ISBN object
              
                let savedBook = try Book( // 3. Instantiate a new Book object with the corresponding input fields
                    title: bookTitle,
                    publishingYear: publishingYear,
                    genre: genre,
                    isbn: isbn
                ).save() // 4. Save the new Book object
              
                // 5. Add the corresponding relations for new Book object
                guard let bookToAuthorsRelation = try savedBook.relation?.add("authors", objects: authors), // Book -> Author
                      let bootkToPublishersRelation = try savedBook.relation?.add("publishers", objects: publishers), // Book -> Publisher
                      let genreRelation = try genre.relation?.add("books", objects: [savedBook]) // Genre -> Book
                else {
                    return DispatchQueue.main.async {
                        self.presentAlert(title: "Error", message: "Failed to add relations")
                    }
                }
                               
                // 6. Save the relations
                _ = try bookToAuthorsRelation.save()
                _ = try bootkToPublishersRelation.save()
                _ = try genreRelation.save()
               
                DispatchQueue.main.async {
                    self.presentAlert(title: "Success", message: "Book saved successfully.")
                }
            } catch {
                DispatchQueue.main.async {
                    self.presentAlert(title: "Error", message: "Failed to save book: \((error as! ParseError).message)")
                }
            }
        }
    }
45
    ...
}
﻿
- Interroger les relations
Pour 1:1 relations, étant donné le parent Book et son enfant ISBN, nous interrogeons l'enfant correspondant en l'incluant dans la Book requête
Swift
 let query = Book.query().include("isbn")
2
 let books = try query.find() // Retrieves synchronously all the books together with its isbn
4
 query.find { result in // Retrieves asynchronously all the books together with its isbn
     // Handle the result
 }
8
 let query = Book.query().include("isbn")
2
 let books = try query.find() // Retrieves synchronously all the books together with its isbn
4
 query.find { result in // Retrieves asynchronously all the books together with its isbn
     // Handle the result
 }
8
﻿
Avec cela, tous les livres de la query auront également la isbn propriété correctement définie avec l'objet ISBN associé.
D'autre part, afin de récupérer des objets avec une 1:N relation, le ParseObject protocole fournit la méthode statique queryRelation(_,parent:). En fournissant le nom de la relation (comme premier paramètre) et le parent, cette méthode nous permet de créer la requête requise. Par exemple, pour récupérer tous les Author liés à un Book spécifique, nous pouvons utiliser le snippet suivant.
Swift
 let book: Book // Book from which we are trying to retrieve its related authors
2
 do {
     let authorsQuery = try Author.queryRelations("authors", parent: book) // 'authors' is the name of the relation it was saved with
      
     authorsQuery.find { [weak self] result in
         switch result {
         case .success(let authors):
             self?.authors = authors
                  
            DispatchQueue.main.async {
                // Update the UI
            }
            case .failure(let error):
                DispatchQueue.main.async {
                    self?.presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
                }
            }
        }
    }
} catch {
    if let error = error as? ParseError {
        presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
    } else {
        presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.localizedDescription)")
    }
}
 let book: Book // Book from which we are trying to retrieve its related authors
2
 do {
     let authorsQuery = try Author.queryRelations("authors", parent: book) // 'authors' is the name of the relation it was saved with
      
     authorsQuery.find { [weak self] result in
         switch result {
         case .success(let authors):
             self?.authors = authors
                  
            DispatchQueue.main.async {
                // Update the UI
            }
            case .failure(let error):
                DispatchQueue.main.async {
                    self?.presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
                }
            }
        }
    }
} catch {
    if let error = error as? ParseError {
        presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
    } else {
        presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.localizedDescription)")
    }
}
﻿
De même, nous pouvons interroger d'autres objets connexes tels que Publisher.
Dans le BookDetailsController.swift fichier, nous implémentons ces requêtes pour afficher la relation qu'un livre a avec les auteurs et les éditeurs.
Swift
// BookDetailsController.swift file
class BookDetailsController: UITableViewController {
    ...
  
    /// Retrieves the book's details, i.e., its relation with authors and publishers
    private func fetchDetails() {
        do {
            // Constructs the relations you want to query
            let publishersQuery = try Publisher.queryRelations("publishers", parent: book)
            let authorsQuery = try Author.queryRelations("authors", parent: book)
          
            // Obtains the publishers related to book and display them on the tableView, it presents an error if happened.
            publishersQuery.find { [weak self] result in
                switch result {
                case .success(let publishers):
                    self?.publishers = publishers
                  
                    // Update the UI
                    DispatchQueue.main.async {
                        self?.tableView.reloadSections(IndexSet([Section.publisher.rawValue]), with: .none)
                    }
                case .failure(let error):
                    DispatchQueue.main.async {
                        self?.presentAlert(title: "Error", message: "Failed to retrieve publishers: \(error.message)")
                    }
                }
            }
          
            // Obtains the authors related to book and display them on the tableView, it presents an error if happened.
            authorsQuery.find { [weak self] result in
                switch result {
                case .success(let authors):
                    self?.authors = authors
                  
                    // Update the UI
                    DispatchQueue.main.async {
                        self?.tableView.reloadSections(IndexSet([Section.author.rawValue]), with: .none)
                    }
                case .failure(let error):
                    DispatchQueue.main.async {
                        self?.presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
                    }
                }
            }
        } catch { // If there was an error during the creation of the queries, this block should catch it
            if let error = error as? ParseError {
                presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
            } else {
                presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.localizedDescription)")
            }
        }
    }
  
    ...
}
// BookDetailsController.swift file
class BookDetailsController: UITableViewController {
    ...
  
    /// Retrieves the book's details, i.e., its relation with authors and publishers
    private func fetchDetails() {
        do {
            // Constructs the relations you want to query
            let publishersQuery = try Publisher.queryRelations("publishers", parent: book)
            let authorsQuery = try Author.queryRelations("authors", parent: book)
          
            // Obtains the publishers related to book and display them on the tableView, it presents an error if happened.
            publishersQuery.find { [weak self] result in
                switch result {
                case .success(let publishers):
                    self?.publishers = publishers
                  
                    // Update the UI
                    DispatchQueue.main.async {
                        self?.tableView.reloadSections(IndexSet([Section.publisher.rawValue]), with: .none)
                    }
                case .failure(let error):
                    DispatchQueue.main.async {
                        self?.presentAlert(title: "Error", message: "Failed to retrieve publishers: \(error.message)")
                    }
                }
            }
          
            // Obtains the authors related to book and display them on the tableView, it presents an error if happened.
            authorsQuery.find { [weak self] result in
                switch result {
                case .success(let authors):
                    self?.authors = authors
                  
                    // Update the UI
                    DispatchQueue.main.async {
                        self?.tableView.reloadSections(IndexSet([Section.author.rawValue]), with: .none)
                    }
                case .failure(let error):
                    DispatchQueue.main.async {
                        self?.presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
                    }
                }
            }
        } catch { // If there was an error during the creation of the queries, this block should catch it
            if let error = error as? ParseError {
                presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.message)")
            } else {
                presentAlert(title: "Error", message: "Failed to retrieve authors: \(error.localizedDescription)")
            }
        }
    }
  
    ...
}
﻿
- Exécutez l'application !
Avant d'appuyer sur le bouton exécuter sur XCode, n'oubliez pas de configurer votre Back4App  application dans la AppDelegate classe!
Vous devez ajouter quelques Genre’s, Publisher’s et Author’s avant d'ajouter un nouveau livre. Ensuite, vous pouvez commencer à entrer les informations d'un livre pour les enregistrer dans votre base de données Back4App. Une fois que vous avez enregistré un livre, ouvrez votre tableau de bord Back4App et allez à votre application liée au XCode projet. Dans la section Base de données, vous trouverez la classe Book où tous les livres créés par l' iOS App sont stockés.
De plus, vous pouvez voir que Back4App a automatiquement créé la classe ISBN afin de la relier à son Book correspondant. Si vous revenez à la classe Book , vous pouvez identifier les types de données pour chaque type de relation. Dans le cas de ISBN et Genre, le type de données est un Pointer<>. D'autre part, pour des relations comme Author et Publisher, le type de données est Relation<>. C'est une différence clé à garder à l'esprit lors de la construction des relations.