Guide Technique : Requêtes de Base avec ParseSwift SDK

15min
Requêtes de base
Introduction
Dans la plupart des cas d'utilisation, nous devons récupérer des données d'une base de données avec certaines conditions. Ces conditions peuvent inclure des comparaisons complexes et des exigences de tri. Ainsi, dans toute application, il est fondamental de construire des requêtes efficaces et, en même temps, la base de données doit être capable de les exécuter aussi rapidement que possible.
Le ParseSwift SDK fournit les outils nécessaires pour que vous puissiez construire n'importe quelle requête selon les exigences de l'application. Dans ce tutoriel, nous explorons ces outils et les utilisons dans une application du monde réel.
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 créer des requêtes de base pour récupérer des données d'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 de 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 Contacts
Le modèle de projet est une application Contacts où l'utilisateur ajoute les informations d'un contact pour les enregistrer dans une base de données Back4App.
﻿
Sur l'écran d'accueil de l'application, vous trouverez un ensemble de boutons pour différents types de requêtes. En utilisant le + bouton situé en haut à droite de la barre de navigation, nous pouvons ajouter autant de Contacts que nécessaire.
Référence rapide des commandes que nous allons utiliser
Pour cet exemple, nous utilisons l'objet Contact﻿
Swift
 import Foundation
 import ParseSwift
3
 struct Contact: ParseObject {
     // Required properties from ParseObject protocol
     var originalData: Data?
     var objectId: String?
     var createdAt: Date?
     var updatedAt: Date?
    var ACL: ParseACL?
  
    // Custom fields for the contact's information
    var name: String?
    var birthday: Date?
    var numberOfFriends: Int?
    var favoriteFoods: [String]?
  
    ...
}
 import Foundation
 import ParseSwift
3
 struct Contact: ParseObject {
     // Required properties from ParseObject protocol
     var originalData: Data?
     var objectId: String?
     var createdAt: Date?
     var updatedAt: Date?
    var ACL: ParseACL?
  
    // Custom fields for the contact's information
    var name: String?
    var birthday: Date?
    var numberOfFriends: Int?
    var favoriteFoods: [String]?
  
    ...
}
﻿
Les méthodes suivantes nous permettront de sauvegarder et de interrogerContact objets:
Create contact
Query all
Query by name
Query by friend count
Query with ordering
//When creating and saving a new instance of Contact we can use
 var newContact: Contact = Contact(name: "John Doe", birthday: Date(), numberOfFriends: 5, favoriteFoods: ["Bread", "Pizza"])
2
 // Saves newContact on your Back4App Database synchronously and returns the new saved Item. It throws and error if something went wrong.
 let savedContact = try? newContact.save()
5
 // Saves newContact on your Back4App Database asynchronously, and passes a Result<Contact, ParseError> object to the completion block to handle the save process.
 newContact.save { result in
     // Handle the result to check wether the save process was successfull or not
 }
//When creating and saving a new instance of Contact we can use
 var newContact: Contact = Contact(name: "John Doe", birthday: Date(), numberOfFriends: 5, favoriteFoods: ["Bread", "Pizza"])
2
 // Saves newContact on your Back4App Database synchronously and returns the new saved Item. It throws and error if something went wrong.
 let savedContact = try? newContact.save()
5
 // Saves newContact on your Back4App Database asynchronously, and passes a Result<Contact, ParseError> object to the completion block to handle the save process.
 newContact.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 Contacts
Le XCode le 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﻿
Pour se concentrer sur l'objectif principal de ce guide, nous ne détaillerons que les sections strictement liées aux requêtes et au ParseSwift SDK.
- Flux CRUD supplémentaires
Avant de commencer avec les requêtes, il est nécessaire d'avoir déjà quelques contacts enregistrés dans votre base de données Back4App. Dans la NewContactController classe, nous implémentons un formulaire de base pour ajouter un Contact. Pour enregistrer une instance d'un Contact objet, nous utilisons la handleAddContact() méthode implémentée dans la NewContactController classe
Swift
 // NewContactController.swift file
 ...
3
 extension NewContactController {
     /// Retrieves the info the user entered for a new contact and stores it on your Back4App Database
     @objc fileprivate func handleAddContact() {
         view.endEditing(true)
      
         // Collect the contact's information from the form
        guard let name = nameTextField.text,
              let numberOfFriendsString = numberOfFriendsTextField.text,
              let numberOfFriends = Int(numberOfFriendsString),
              let favoriteFoods = favoriteFoodsTextField.text?.split(separator: ",") else {
            return showAlert(title: "Error", message: "The data you entered is con valid.")
        }
      
        // Once the contact's information is collected, instantiate a Contact object to save it on your Back4App Database
        let contact = Contact(
            name: name,
            birthday: birthdayDatePicker.date,
            numberOfFriends: numberOfFriends,
            favoriteFoods: favoriteFoods.compactMap { String($0).trimmingCharacters(in: .whitespaces) }
        )
      
        // Save the new Contact
        contact.save { [weak self] result in
            switch result {
            case .success(_):
                self?.showAlert(title: "Success", message: "Contact saved.") {
                    self?.dismiss(animated: true, completion: nil)
                }
            case .failure(let error):
                self?.showAlert(title: "Error", message: "Failed to save contact: \(error.message)")
            }
        }
    }
}
 // NewContactController.swift file
 ...
3
 extension NewContactController {
     /// Retrieves the info the user entered for a new contact and stores it on your Back4App Database
     @objc fileprivate func handleAddContact() {
         view.endEditing(true)
      
         // Collect the contact's information from the form
        guard let name = nameTextField.text,
              let numberOfFriendsString = numberOfFriendsTextField.text,
              let numberOfFriends = Int(numberOfFriendsString),
              let favoriteFoods = favoriteFoodsTextField.text?.split(separator: ",") else {
            return showAlert(title: "Error", message: "The data you entered is con valid.")
        }
      
        // Once the contact's information is collected, instantiate a Contact object to save it on your Back4App Database
        let contact = Contact(
            name: name,
            birthday: birthdayDatePicker.date,
            numberOfFriends: numberOfFriends,
            favoriteFoods: favoriteFoods.compactMap { String($0).trimmingCharacters(in: .whitespaces) }
        )
      
        // Save the new Contact
        contact.save { [weak self] result in
            switch result {
            case .success(_):
                self?.showAlert(title: "Success", message: "Contact saved.") {
                    self?.dismiss(animated: true, completion: nil)
                }
            case .failure(let error):
                self?.showAlert(title: "Error", message: "Failed to save contact: \(error.message)")
            }
        }
    }
}
﻿
Pour plus de détails sur cette étape, vous pouvez consulter le guide des opérations de base.
- Effectuer des requêtes de base
- Par nom
Le premier exemple que nous examinons est une requête qui nous permet de récupérer des contacts ayant une sous-chaîne spécifique dans leur nom champ. Pour ce faire, nous créons d'abord un QueryConstraint objet. Cet objet contiendra la contrainte que nous souhaitons. Le ParseSwift SDK fournit les méthodes suivantes pour (indirectement) créer un QueryConstraint﻿
Swift
 // QueryConstraint.swift file
2
 /**
   Add a constraint for finding string values that contain a provided substring.
   - warning: This will be slow for large datasets.
   - parameter key: The key that the string to match is stored in.
   - parameter substring: The substring that the value must contain.
   - parameter modifiers: Any of the following supported PCRE modifiers (defaults to nil):
     - `i` - Case insensitive search
    - `m` - Search across multiple lines of input
  - returns: The resulting `QueryConstraint`.
 */
public func containsString(key: String, substring: String, modifiers: String? = nil) -> QueryConstraint
14
/**
 Add a constraint that requires that a key is equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 - warning: See `equalTo` for more information.
 Behavior changes based on `ParseSwift.configuration.isUsingEqualQueryConstraint`
 where isUsingEqualQueryConstraint == true is known not to work for LiveQuery on
 Parse Servers  <= 5.0.0.
 */
public func == <T>(key: String, value: T) -> QueryConstraint where T: Encodable
 // QueryConstraint.swift file
2
 /**
   Add a constraint for finding string values that contain a provided substring.
   - warning: This will be slow for large datasets.
   - parameter key: The key that the string to match is stored in.
   - parameter substring: The substring that the value must contain.
   - parameter modifiers: Any of the following supported PCRE modifiers (defaults to nil):
     - `i` - Case insensitive search
    - `m` - Search across multiple lines of input
  - returns: The resulting `QueryConstraint`.
 */
public func containsString(key: String, substring: String, modifiers: String? = nil) -> QueryConstraint
14
/**
 Add a constraint that requires that a key is equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 - warning: See `equalTo` for more information.
 Behavior changes based on `ParseSwift.configuration.isUsingEqualQueryConstraint`
 where isUsingEqualQueryConstraint == true is known not to work for LiveQuery on
 Parse Servers  <= 5.0.0.
 */
public func == <T>(key: String, value: T) -> QueryConstraint where T: Encodable
﻿
Par exemple, une requête qui nous permet de récupérer tous les Contacts ayant John dans leur nom peut être créée avec
Swift
 // Create the query sending the constraint as parameter
 let constraint: QueryConstraint = containsString(key: "name", substring: "John") // The first parameter (key) referres to the name of the field
 let query = Contact.query(constrain)
4
 // Retrieve the contacts asynchronously (or sinchronously if needed)
 query.find() { result in
     // Handle the result and do the corresponding UI update
 }
 // Create the query sending the constraint as parameter
 let constraint: QueryConstraint = containsString(key: "name", substring: "John") // The first parameter (key) referres to the name of the field
 let query = Contact.query(constrain)
4
 // Retrieve the contacts asynchronously (or sinchronously if needed)
 query.find() { result in
     // Handle the result and do the corresponding UI update
 }
﻿
Dans le cas où la contrainte exige que le nom du champ corresponde exactement à une chaîne donnée, nous pouvons utiliser
Swift
 // Create the query sending the constraint as parameter
 let value = "John"
 let constraint: QueryConstraint = "name" == value
 let query = Contact.query(constrain)
 // Create the query sending the constraint as parameter
 let value = "John"
 let constraint: QueryConstraint = "name" == value
 let query = Contact.query(constrain)
﻿
- Par nombre d'amis
Une requête avec une contrainte impliquant une comparaison numérique peut être construite en créant unQueryConstraint avec
Swift
 /**
  Add a constraint that requires that a key is greater than a value.
  - parameter key: The key that the value is stored in.
  - parameter value: The value to compare.
  - returns: The same instance of `QueryConstraint` as the receiver.
  */
 public func > <T>(key: String, value: T) -> QueryConstraint where T: Encodable
8
 /**
 Add a constraint that requires that a key is greater than or equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func >= <T>(key: String, value: T) -> QueryConstraint where T: Encodable
16
/**
 Add a constraint that requires that a key is less than a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func < <T>(key: String, value: T) -> QueryConstraint where T: Encodable
24
/**
 Add a constraint that requires that a key is less than or equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func <= <T>(key: String, value: T) -> QueryConstraint where T: Encodable

 /**
  Add a constraint that requires that a key is greater than a value.
  - parameter key: The key that the value is stored in.
  - parameter value: The value to compare.
  - returns: The same instance of `QueryConstraint` as the receiver.
  */
 public func > <T>(key: String, value: T) -> QueryConstraint where T: Encodable
8
 /**
 Add a constraint that requires that a key is greater than or equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func >= <T>(key: String, value: T) -> QueryConstraint where T: Encodable
16
/**
 Add a constraint that requires that a key is less than a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func < <T>(key: String, value: T) -> QueryConstraint where T: Encodable
24
/**
 Add a constraint that requires that a key is less than or equal to a value.
 - parameter key: The key that the value is stored in.
 - parameter value: The value to compare.
 - returns: The same instance of `QueryConstraint` as the receiver.
 */
public func <= <T>(key: String, value: T) -> QueryConstraint where T: Encodable
﻿
Pour interroger tous les contacts ayant 30 amis ou plus, nous utilisons
Swift
 let query = Contacts.query("numberOfFriends" >= 30)
2
 // Retrieve the contacts asynchronously (or sinchronously if needed)
 query.find() { result in
     // Handle the result and do the corresponding UI update
 }
 let query = Contacts.query("numberOfFriends" >= 30)
2
 // Retrieve the contacts asynchronously (or sinchronously if needed)
 query.find() { result in
     // Handle the result and do the corresponding UI update
 }
﻿
- Ordonnancement des résultats de la requête
Pour ordonner les résultats d'une requête, l' Query<contacts> objet fournit la méthode order(_:) qui retourne un nouvel Query<contact> objet en tenant compte de l'option d'ordonnancement demandée. En paramètre, nous passons une énumération (Query<contact>.Order) pour indiquer l'ordonnancement que nous souhaitons. Le snippet suivant applique un ordre décroissant basé sur le birthday champ
Swift
 // A query without order to retrieve all the Contact items
 let unorderedQuery = Contact.query()
3
 // Sorts the contacts based on their brithday. The parameter in the enumeration is the key of the field used to order the results
 let descendingOrder = Query<Contact>.Order.descending("birthday")
6
 let orderedQuery = unorderedQuery.order([descendingOrder]) // Returns a new query with the requested (descending) ordering option
8
 // Executes que query asynchronously and returns a Result<[Contact], ParseError> object with the result
orderedContacts.find() { result in
    // Handle the result
}
 // A query without order to retrieve all the Contact items
 let unorderedQuery = Contact.query()
3
 // Sorts the contacts based on their brithday. The parameter in the enumeration is the key of the field used to order the results
 let descendingOrder = Query<Contact>.Order.descending("birthday")
6
 let orderedQuery = unorderedQuery.order([descendingOrder]) // Returns a new query with the requested (descending) ordering option
8
 // Executes que query asynchronously and returns a Result<[Contact], ParseError> object with the result
orderedContacts.find() { result in
    // Handle the result
}
﻿
Dans le exemple de projet, nous avons implémenté les requêtes mentionnées ci-dessus. La ContactsController classe a la méthode fetchContacts() où vous trouverez le snippet suivant 
Swift
 ...
2
 class ContactsController {
     let queryType: QueryType
5
     ...
7
     private func fetchContacts() {
         // We create a Query<Contact> according to the queryType enumeration
        let query: Query<Contact> = {
            switch queryType {
            case .byName(let value):
                return Contact.query(containsString(key: "name", substring: value))
            case .byNumberOfFriends(let quantity):
                return Contact.query("numberOfFriends" >= quantity)
            case .byOrdering(let order):
                let query = Contact.query()
                switch order {
                case .ascending: return query.order([.ascending("birthday")])
                case .descending: return query.order([.descending("birthday")])
                }
            case .all:
                return Contact.query()
            }
        }()
      
        // Execute the query
        query.find { [weak self] result in
            switch result {
            case .success(let contacts):
                self?.contacts = contacts
              
                // Update the UI
                DispatchQueue.main.async { self?.tableView.reloadData() }
            case .failure(let error):
                // Notify the user about the error that happened during the fetching process
                self?.showAlert(title: "Error", message: "Failed to retrieve contacts: \(error.message)")
                return
            }
        }
    }
}
 ...
2
 class ContactsController {
     let queryType: QueryType
5
     ...
7
     private func fetchContacts() {
         // We create a Query<Contact> according to the queryType enumeration
        let query: Query<Contact> = {
            switch queryType {
            case .byName(let value):
                return Contact.query(containsString(key: "name", substring: value))
            case .byNumberOfFriends(let quantity):
                return Contact.query("numberOfFriends" >= quantity)
            case .byOrdering(let order):
                let query = Contact.query()
                switch order {
                case .ascending: return query.order([.ascending("birthday")])
                case .descending: return query.order([.descending("birthday")])
                }
            case .all:
                return Contact.query()
            }
        }()
      
        // Execute the query
        query.find { [weak self] result in
            switch result {
            case .success(let contacts):
                self?.contacts = contacts
              
                // Update the UI
                DispatchQueue.main.async { self?.tableView.reloadData() }
            case .failure(let error):
                // Notify the user about the error that happened during the fetching process
                self?.showAlert(title: "Error", message: "Failed to retrieve contacts: \(error.message)")
                return
            }
        }
    }
}
﻿
- Exécutez l'application !
Avant d'appuyer sur le bouton d'exécution sur XCode, n'oubliez pas de configurer votre Back4App application dans le AppDelegate classe !
En utilisant le+ bouton dans la barre de navigation, ajoutez quelques contacts et testez les différentes requêtes.
Mis à jour 27 Jan 2025
Cette page vous a-t-elle aidée?
Implémentation de relations avec Parse Swift SDK sur iOS
Livre de recettes: Optimiser les requêtes ParseSwift
Guide Technique : Requêtes de Base avec ParseSwift SDK

Requêtes de base

Introduction

Objectif

Prérequis

Comprendre notre application Contacts

Référence rapide des commandes que nous allons utiliser

1 - Téléchargez le modèle de l'application Contacts

2 - Flux CRUD supplémentaires

3 - Effectuer des requêtes de base

4 - Exécutez l'application !
