Livre de recettes: Optimiser les requêtes ParseSwift

20min
Livre de recettes de requêtes pour ParseSwift
Introduction
Dans le guide des requêtes de base, nous avons introduit certaines des méthodes de base pour construire des requêtes et récupérer des données d'une Base de données Back4App.
Le ParseSwift SDK offre des moyens pratiques de construire des requêtes plus complexes pour des applications du monde réel.
Dans ce guide, vous plongerez profondément dans la Query<U> (classe générique) et découvrirez toutes les méthodes que vous pouvez utiliser pour construire vos requêtes. Vous utiliserez une classe de base de données simple (nommée Profile) avec des données simulées pour effectuer des requêtes en utilisant Swift.
Avant de commencer, nous devrions établir quelques concepts sur les objets et les types de données. Dans ce guide, nous faisons référence aux objets comme tout type de données (comme les structures) qui peut être stocké dans une base de données. Dans certaines situations, ils sont également appelés éléments ou items.
Les propriétés sont les membres d'un type de données (principalement des structures). Cependant, ici, nous les appelons généralement champs. ParseSwift utilise le terme ‘clé’ pour indiquer le nom des propriétés. Ainsi, tout paramètre étiqueté comme ‘clé’ dans n'importe quelle méthode du ParseSwift SDK indique que sa valeur doit correspondre au nom d'un champ.
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
Pour explorer les différentes méthodes que laQuery<U> classe fournit pour exécuter des requêtes.
La classe Query<U>
Pour ce guide, nous allons interroger des informations sur le contact d'une personne. Ces données sont stockées sous la classe Profile dans la base de données Back4App . Afin de récupérer des profils via une application iOS, nous devons créer la Profile structure qui contiendra ces informations.
Swift
1   import ParseSwift
2   ...
3
4   struct Profile: ParseObject {
5       ...
6    
7       // Custom properties to organize the person's information
8       var name: String?
9       var birthday: Date?
10      var numberOfFriends: Int?
11      var favoriteFoods: [String]?
12      var luckyNumbers: [Int]?
13      var lastLoginLocation: ParseGeoPoint? // A data type to store coordinates for geolocation
14      var isActive: Bool?
15      var membership: Pointer<Membership>? // More details about Membership below
16    
17      ...
18  }
1   import ParseSwift
2   ...
3
4   struct Profile: ParseObject {
5       ...
6    
7       // Custom properties to organize the person's information
8       var name: String?
9       var birthday: Date?
10      var numberOfFriends: Int?
11      var favoriteFoods: [String]?
12      var luckyNumbers: [Int]?
13      var lastLoginLocation: ParseGeoPoint? // A data type to store coordinates for geolocation
14      var isActive: Bool?
15      var membership: Pointer<Membership>? // More details about Membership below
16    
17      ...
18  }
﻿
De plus, nous utilisons l'objet Adhésion pour montrer comment les requêtes entre Profil et Adhésion interagissent entre elles. La Adhésion struct est implémentée de la manière suivante
Swift
1   import ParseSwift
2   ...
3
4   struct Membership: ParseObject {
5       ...
6    
7       // Custom properties to organize the membership's information
8       var typeDescription: String?
9       var expirationDate: Date?
10
11      ...
12  }
1   import ParseSwift
2   ...
3
4   struct Membership: ParseObject {
5       ...
6    
7       // Custom properties to organize the membership's information
8       var typeDescription: String?
9       var expirationDate: Date?
10
11      ...
12  }
﻿
Toute opération de requête sur une base de données Back4App est effectuée par la classe générique Query<Profil> où le type générique Profil (conformant au ParseSwift protocole) est l'objet que nous essayons de récupérer. Après avoir instancié un Query<Profil> objet, nous devons appeler l'une de ses find(_) méthodes (voir le guide des requêtes de base) pour gérer le résultat retourné par la requête.
Vous pouvez en lire plus sur la Query<U> classe ici dans la documentation officielle.
Sauvegarde des objets de données
Avec le code suivant, nous créons et sauvegardons des données pour tester diverses requêtes
Swift
1   let adamSandler = Profile(
2     name: "Adam Sandler",
3     birthday: Date(string: "09/09/1996"),
4     numberOfFriends: 2,
5     favoriteFoods: ["Lobster", "Bread"],
6     luckyNumbers: [2, 7],
7     lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
8     isActive: false,
9     membership: nil
10  )
11
12  let britneySpears = Profile(
13    name: "Britney Spears",
14    birthday: Date(string: "12/02/1981"),
15    numberOfFriends: 52,
16    favoriteFoods: ["Cake", "Bread"],
17    luckyNumbers: [22, 7],
18    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
19    isActive: true,
20    membership: nil
21  )
22  
23  let carsonKressley = Profile(
24    name: "Carson Kressley",
25    birthday: Date(string: "03/27/1975"),
26    numberOfFriends: 12,
27    favoriteFoods: ["Fish", "Cookies"],
28    luckyNumbers: [8, 7],
29    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
30    isActive: true,
31    membership: nil
32  )
33
34  // We create and save a Membership object
35  let premiumMembership = Membership(typeDescription: "Premium", expirationDate: Date(string: "10/10/2030"))
36  let savedPremiumMembership = try! premiumMembership.save() // Careful with the forced unwrap
37 
38  let danAykroyd = Profile(
39    name: "Dan Aykroyd",
40    birthday: Date(string: "07/01/1952"),
41    numberOfFriends: 66,
42    favoriteFoods: ["Jam", "Peanut Butter"],
43    luckyNumbers: [22, 77],
44    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
45    isActive: true,
46    membership: try? .init(savedPremiumMembership)
47  )
48
49  let eddyMurphy = Profile(
50    name: "Eddie Murphy",
51    birthday: Date(string: "04/03/1961"),
52    numberOfFriends: 49,
53    favoriteFoods: ["Lettuce", "Pepper"],
54    luckyNumbers: [6, 5],
55   lastLoginLocation: try? ParseGeoPoint(latitude: -27.104919974838154, longitude: -52.61428045237739),
56    isActive: false,
57    membership: nil
58  )
59
60  let fergie = Profile(
61    name: "Fergie",
62    birthday: Date(string: "03/27/1975"),
63    numberOfFriends: 55,
64    favoriteFoods: ["Lobster", "Shrimp"],
65    luckyNumbers: [12, 7],
66    lastLoginLocation: try? ParseGeoPoint(latitude: -27.104919974838154, longitude: -52.61428045237739),
67    isActive: false,
68    membership: nil
69  )
70 
71  do {
72    _ = try? adamSandler.save()
73    _ = try? britneySpears.save()        
74    _ = try? carsonKressley.save()
75    _ = try? danAykroyd.save()
76    _ = try? eddyMurphy.save()
77  } catch {
78    // Handle the errors here
79  }
1   let adamSandler = Profile(
2     name: "Adam Sandler",
3     birthday: Date(string: "09/09/1996"),
4     numberOfFriends: 2,
5     favoriteFoods: ["Lobster", "Bread"],
6     luckyNumbers: [2, 7],
7     lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
8     isActive: false,
9     membership: nil
10  )
11
12  let britneySpears = Profile(
13    name: "Britney Spears",
14    birthday: Date(string: "12/02/1981"),
15    numberOfFriends: 52,
16    favoriteFoods: ["Cake", "Bread"],
17    luckyNumbers: [22, 7],
18    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
19    isActive: true,
20    membership: nil
21  )
22  
23  let carsonKressley = Profile(
24    name: "Carson Kressley",
25    birthday: Date(string: "03/27/1975"),
26    numberOfFriends: 12,
27    favoriteFoods: ["Fish", "Cookies"],
28    luckyNumbers: [8, 7],
29    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
30    isActive: true,
31    membership: nil
32  )
33
34  // We create and save a Membership object
35  let premiumMembership = Membership(typeDescription: "Premium", expirationDate: Date(string: "10/10/2030"))
36  let savedPremiumMembership = try! premiumMembership.save() // Careful with the forced unwrap
37 
38  let danAykroyd = Profile(
39    name: "Dan Aykroyd",
40    birthday: Date(string: "07/01/1952"),
41    numberOfFriends: 66,
42    favoriteFoods: ["Jam", "Peanut Butter"],
43    luckyNumbers: [22, 77],
44    lastLoginLocation: try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319),
45    isActive: true,
46    membership: try? .init(savedPremiumMembership)
47  )
48
49  let eddyMurphy = Profile(
50    name: "Eddie Murphy",
51    birthday: Date(string: "04/03/1961"),
52    numberOfFriends: 49,
53    favoriteFoods: ["Lettuce", "Pepper"],
54    luckyNumbers: [6, 5],
55   lastLoginLocation: try? ParseGeoPoint(latitude: -27.104919974838154, longitude: -52.61428045237739),
56    isActive: false,
57    membership: nil
58  )
59
60  let fergie = Profile(
61    name: "Fergie",
62    birthday: Date(string: "03/27/1975"),
63    numberOfFriends: 55,
64    favoriteFoods: ["Lobster", "Shrimp"],
65    luckyNumbers: [12, 7],
66    lastLoginLocation: try? ParseGeoPoint(latitude: -27.104919974838154, longitude: -52.61428045237739),
67    isActive: false,
68    membership: nil
69  )
70 
71  do {
72    _ = try? adamSandler.save()
73    _ = try? britneySpears.save()        
74    _ = try? carsonKressley.save()
75    _ = try? danAykroyd.save()
76    _ = try? eddyMurphy.save()
77  } catch {
78    // Handle the errors here
79  }
﻿
Une fois le code ci-dessus exécuté, nous devrions avoir une petite base de données avec laquelle travailler.
Voir plus sur la façon de sauvegarder des données avec ParseSwift à Objets de données iOS.
Récupérateurs de requêtes
Ces méthodes sont responsables de l'exécution de la requête et de la récupération de ses résultats, étant toujours présentes dans votre implémentation de requête.
Find
First
Count
Distinct
Find all
Using the objectId
//This is the basic method for retrieving your query results
1   let query = Profile.query() // Instantiate a Query<Profile> class with no additional constraints
2
3   let profiles = try? query.find() // Executes the query synchronously returns and array of Profiles. It throws an error if something happened
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
//This is the basic method for retrieving your query results
1   let query = Profile.query() // Instantiate a Query<Profile> class with no additional constraints
2
3   let profiles = try? query.find() // Executes the query synchronously returns and array of Profiles. It throws an error if something happened
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
﻿
Requêtes avec des contraintes sur les champs de type chaîne
Nous commençons maintenant à appliquer des contraintes spécifiques aux requêtes. Tout d'abord, nous allons imposer des contraintes qui sélectionnent des objets uniquement lorsque un String champ de type satisfait une condition donnée. Cela et toute autre contrainte de type imposée sur un Query<Profile> objet se fait via l'objet QueryConstraint. Ci-dessous et dans les sections suivantes, nous détaillons comment construire de telles contraintes.
Equal
Regular expression
Contains substring
Matches text
//Used when we need to select all the objects which have a field equal to a given String. We use the == operator to construct the corresponding constraint. On the left-hand side goes the field’s name and on the right hand side goes the String to compare against
1   let constraint: QueryConstraint = "name" == "Fergie" // Selects all Profiles with name equals to Fergie
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
//Used when we need to select all the objects which have a field equal to a given String. We use the == operator to construct the corresponding constraint. On the left-hand side goes the field’s name and on the right hand side goes the String to compare against
1   let constraint: QueryConstraint = "name" == "Fergie" // Selects all Profiles with name equals to Fergie
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
﻿
Requêtes avec des contraintes sur des champs comparables
Il est très courant d'essayer de sélectionner des objets où un champ de type nombre doit être égal, distinct, supérieur ou inférieur à une valeur donnée. Cela se fait en utilisant les opérations comparables suivantes
Equal
Not equal
Less than
Less than or equal
Greater than
Greater than or equal
//Use this constraint when you need to select objects where a certain number type field is equal to a given value.
1   let constraint: QueryConstraint = "numberOfFriends" == 2 // Selects all Profiles with number of friends = 2
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
//Use this constraint when you need to select objects where a certain number type field is equal to a given value.
1   let constraint: QueryConstraint = "numberOfFriends" == 2 // Selects all Profiles with number of friends = 2
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
﻿
Ces contraintes fonctionnent également sur Date des champs de type. Par exemple, nous pouvons avoir
Swift
1   let constraint: QueryConstraint = "birthday" > Date(string: "08/19/1980") // Selects all Profiles who were born after 08/19/1980
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
1   let constraint: QueryConstraint = "birthday" > Date(string: "08/19/1980") // Selects all Profiles who were born after 08/19/1980
2   let query = Profile.query(constraint)
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
﻿
Pour Bool des champs de type, nous avons les options Égal et Pas égal . Par exemple
Swift
1   let constraint: QueryConstraint = "isActive" == true
2   let query = Profile.query(constraint) // Selects all active Profiles
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
1   let constraint: QueryConstraint = "isActive" == true
2   let query = Profile.query(constraint) // Selects all active Profiles
3
4   let profiles = try? query.find() // Executes the query synchronously
5
6   query.find { result in // Executes the query asynchronously
7     // Handle the result (of type Result<[Profile], ParseError>)
8   }
﻿
Requêtes avec des contraintes impliquant la géolocalisation
Pour les champs contenant des données de localisation (c'est-à-dire de type ParseGeoPoint) nous avons les options de requête suivantes.
Near
Contains
Within geo box
Within km/mph
Within Polygon
Within radians
//In order to select objects where one of their ParseGeoPoint type fields is near to another given geopoint, we use
1   guard let geopoint = try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319) else {
2     return
3   }
4
5   let query = Profile.query(near(key: "lastLoginLocation", geoPoint: geopoint))
6   // near(key:geoPoint:) is a method provided by the ParseSwift SDK
7
8   let profiles = try? query.find() // Executes the query synchronously
9
10  query.find { result in // Executes the query asynchronously
11    // Handle the result (of type Result<[Profile], ParseError>)
12  }
//In order to select objects where one of their ParseGeoPoint type fields is near to another given geopoint, we use
1   guard let geopoint = try? ParseGeoPoint(latitude: 37.38412167489413, longitude: -122.01268034622319) else {
2     return
3   }
4
5   let query = Profile.query(near(key: "lastLoginLocation", geoPoint: geopoint))
6   // near(key:geoPoint:) is a method provided by the ParseSwift SDK
7
8   let profiles = try? query.find() // Executes the query synchronously
9
10  query.find { result in // Executes the query asynchronously
11    // Handle the result (of type Result<[Profile], ParseError>)
12  }
﻿
Requêtes avec des contraintes impliquant des champs de type tableau
Lorsque les objets que nous souhaitons récupérer doivent satisfaire une condition donnée sur l'un de leurs champs de type tableau, ParseSwift SDK fournit les alternatives suivantes pour y parvenir.
Contained in
Contained by
Contains all
//Add a constraint to the query that requires a particular field to be contained in the provided array.
1   let constraint: QueryConstraint = containedIn(key: "luckyNumbers", array: [2, 7])
2   // containedBy(key:array:) is a method provided by the ParseSwift SDK
3
4   let query = Profile.query(constraint)
5
6   let profiles = try? query.find() // Executes the query synchronously
7
8   query.find { result in // Executes the query asynchronously
9     // Handle the result (of type Result<[Profile], ParseError>)
10  }
//Add a constraint to the query that requires a particular field to be contained in the provided array.
1   let constraint: QueryConstraint = containedIn(key: "luckyNumbers", array: [2, 7])
2   // containedBy(key:array:) is a method provided by the ParseSwift SDK
3
4   let query = Profile.query(constraint)
5
6   let profiles = try? query.find() // Executes the query synchronously
7
8   query.find { result in // Executes the query asynchronously
9     // Handle the result (of type Result<[Profile], ParseError>)
10  }
﻿
Requêtes avancées
Jusqu'à présent, nous avons introduit les principales conditions que nous pouvons appliquer sur un champ donné pour sélectionner des objets d'une base de données Back4App en utilisant ParseSwift SDK. Dans cette section, nous continuons avec la composition de requêtes et les requêtes avancées.
Exists
Does not exists
Matches key in query
Does not match key in query
//It is used to select objects depending on the value of a given field not being nil.
1   let constraint: QueryConstraint = exists(key: "membership")
2   // exists(key:) is a method provided by the ParseSwift SDK
3
4   let query = Profile.query(constraint) // Will retrieve all Profiles which have a membership
5
6   let profiles = try? query.find() // Executes the query synchronously
7
8   query.find { result in // Executes the query asynchronously
9     // Handle the result (of type Result<[Profile], ParseError>)
10  }
//It is used to select objects depending on the value of a given field not being nil.
1   let constraint: QueryConstraint = exists(key: "membership")
2   // exists(key:) is a method provided by the ParseSwift SDK
3
4   let query = Profile.query(constraint) // Will retrieve all Profiles which have a membership
5
6   let profiles = try? query.find() // Executes the query synchronously
7
8   query.find { result in // Executes the query asynchronously
9     // Handle the result (of type Result<[Profile], ParseError>)
10  }
﻿
Ordre des requêtes
Trier les résultats d'une requête est essentiel avant de commencer à afficher ou à manipuler ces résultats. Le SDK ParseSwift fournit les options suivantes pour y parvenir.
Ascending
Descending
Text Score
//This kind of sorting procedure relies on a score metric. In order to use this option, the Profile object must conform to the ParseQueryScorable protocol. Once the protocol is implemented, we call the sortByTextScore() method on the Query<Profile> object to obtain a new one that implements the required sorting method.
1   extension Profile: ParseQueryScorable {
2     var score: Double? {
3       // Add the corresponding implementation
4     }  
5   }
6
7   let query = Profile.query().sortByTextScore()
8 
9   let profiles = try? query.find() // Executes the query synchronously
10
11  query.find { result in // Executes the query asynchronously
12    // Handle the result (of type Result<[Profile], ParseError>)
13  }
//This kind of sorting procedure relies on a score metric. In order to use this option, the Profile object must conform to the ParseQueryScorable protocol. Once the protocol is implemented, we call the sortByTextScore() method on the Query<Profile> object to obtain a new one that implements the required sorting method.
1   extension Profile: ParseQueryScorable {
2     var score: Double? {
3       // Add the corresponding implementation
4     }  
5   }
6
7   let query = Profile.query().sortByTextScore()
8 
9   let profiles = try? query.find() // Executes the query synchronously
10
11  query.find { result in // Executes the query asynchronously
12    // Handle the result (of type Result<[Profile], ParseError>)
13  }
﻿
Sélection de champ
Selon les données requises lors d'une requête, cela peut prendre plus ou moins de temps. Dans certains scénarios, il peut suffire de récupérer certains champs d'un objet et d'ignorer les champs inutiles. De plus, en sélectionnant uniquement les champs dont nous avons besoin dans une requête, nous évitons de surcharger les données et améliorons les performances du processus de récupération.
Exclude
Include
Include all
Select
//Calling the exclude(_:) method on a query returns a new query that will exclude the fields passed (in variadic format) as the argument.
1   let query = Profile.query().exclude("name", "numberOfFriends")
2
3   let profiles = try? query.find() // Executes the query synchronously
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
//Calling the exclude(_:) method on a query returns a new query that will exclude the fields passed (in variadic format) as the argument.
1   let query = Profile.query().exclude("name", "numberOfFriends")
2
3   let profiles = try? query.find() // Executes the query synchronously
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
﻿
Pagination
Dans les grandes bases de données, la pagination est une fonctionnalité fondamentale pour interroger et gérer un grand nombre de résultats. le ParseSwift SDK fournit les méthodes suivantes pour gérer ces situations.
Limit
Skip
With count
//Determines the maximum number of results a query is able to return, the default value is 100. We call the limit(_:) method on the query in question to change this value.
1   let query = Profile.query().limit(2)
2
3   let profiles = try? query.find() // Executes the query synchronously
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
//Determines the maximum number of results a query is able to return, the default value is 100. We call the limit(_:) method on the query in question to change this value.
1   let query = Profile.query().limit(2)
2
3   let profiles = try? query.find() // Executes the query synchronously
4
5   query.find { result in // Executes the query asynchronously
6     // Handle the result (of type Result<[Profile], ParseError>)
7   }
﻿
Requêtes composées
Ces méthodes créeront des requêtes composées, qui peuvent combiner plus d'une Query<Profile> instance pour obtenir des résultats plus complexes.
And
Nor
Or
//Compose a compound query that is the AND of the passed queries. This is accomplished by first instantiating the queries to be used for the AND operation. The and(queries:) method provided by the ParseSwift SDK allows us to perform the AND operation and embed the result in a QueryConstraint object. This constraint is then used to instantiate the final query to be used for retrieveing the results.
1   let query1 = Profile.query("numberOfFriends" > 10)
2   let query2 = Profile.query("numberOfFriends" < 50)
3
4   let query = Profile.query(and(queries: query1, query2))
5   // and(queries:) is a method provided by the ParseSwift SDK. It takes an array of queries and applies the AND op. on them.
6
7   let profiles = try? query.find() // Executes the query synchronously
8   
9   query.find { result in // Executes the query asynchronously
10    // Handle the result (of type Result<[Profile], ParseError>)
11  }
//Compose a compound query that is the AND of the passed queries. This is accomplished by first instantiating the queries to be used for the AND operation. The and(queries:) method provided by the ParseSwift SDK allows us to perform the AND operation and embed the result in a QueryConstraint object. This constraint is then used to instantiate the final query to be used for retrieveing the results.
1   let query1 = Profile.query("numberOfFriends" > 10)
2   let query2 = Profile.query("numberOfFriends" < 50)
3
4   let query = Profile.query(and(queries: query1, query2))
5   // and(queries:) is a method provided by the ParseSwift SDK. It takes an array of queries and applies the AND op. on them.
6
7   let profiles = try? query.find() // Executes the query synchronously
8   
9   query.find { result in // Executes the query asynchronously
10    // Handle the result (of type Result<[Profile], ParseError>)
11  }
﻿
Base de données liée
Ces méthodes sont liées aux préférences et opérations de la base de données.
aggregate
explain
readPreference
//Executes an aggregate query, retrieving objects over a set of input values. To use this feature, instead of executing the query with find(...), we call the aggregate(_:completion:). The first argument of this function is a dictionary containing the information about the pipeline. For more details, refer to MongoDB documentation on aggregate.
1   let query = Profile.query()
2
3   query.aggregate([["pipeline": 5]]) { result in
4     // Handle the result (of type Result<[Profile], ParseError>)
5   }
//Executes an aggregate query, retrieving objects over a set of input values. To use this feature, instead of executing the query with find(...), we call the aggregate(_:completion:). The first argument of this function is a dictionary containing the information about the pipeline. For more details, refer to MongoDB documentation on aggregate.
1   let query = Profile.query()
2
3   query.aggregate([["pipeline": 5]]) { result in
4     // Handle the result (of type Result<[Profile], ParseError>)
5   }
﻿
Conclusion
En utilisant les différentes méthodes, objets et opérateurs fournis par le ParseSwift SDK, nous avons pu comprendre comment construire et récupérer des objets d'une Base de données Back4App. Avec ce livre de recettes, vous devriez être en mesure d'effectuer des requêtes avec des contraintes très flexibles et de gérer les résultats en fonction de votre cas d'utilisation. Pour plus de détails sur l'un des sujets ci-dessus, vous pouvez vous référer au dépôt ParseSwift.
Mis à jour 27 Jan 2025
Cette page vous a-t-elle aidée?
Guide Technique : Requêtes de Base avec ParseSwift SDK
Interroger des données relationnelles avec ParseSwift SDK