Fetch on an array of pointers

[project-saf]

Is there an easy way to convert an Array<Pointer<ParseObject>> into an Array<ParseObject> without looping over it and calling fetch() of each pointer?

[cbaker6]

This all depends on your particular Parse Class setup on your server, but the Swift Playgrounds is the first place to check. If you designed your schema to be [ParseObject] you can use the example in playgrounds

Parse-Swift/ParseSwift.playground/Pages/8 - Pointers.xcplaygroundpage/Contents.swift

Lines 128 to 242 in c0a3a45

	//: Pointer array.
	let otherBook1 = Book(title: "I like this book")
	let otherBook2 = Book(title: "I like this book also")
	var author2 = Author(name: "Bruce", book: newBook)
	author2.otherBooks = [otherBook1, otherBook2]
	author2.save { result in
	switch result {
	case .success(let savedAuthorAndBook):
	assert(savedAuthorAndBook.objectId != nil)
	assert(savedAuthorAndBook.createdAt != nil)
	assert(savedAuthorAndBook.updatedAt != nil)
	assert(savedAuthorAndBook.otherBooks?.count == 2)
	/*:
	Notice the pointer objects have not been updated on the
	client.If you want the latest pointer objects, fetch and include them.
	*/
	print("Saved: \(savedAuthorAndBook)")
	case .failure(let error):
	assertionFailure("Error saving: \(error)")
	}
	}
	//: Query for your new saved author
	let query1 = Author.query("name" == "Bruce")
	query1.first { results in
	switch results {
	case .success(let author):
	print("Found author: \(author)")
	case .failure(let error):
	assertionFailure("Error querying: \(error)")
	}
	}
	/*:
	You will notice in the query above, the fields `book` and `otherBooks` only contain
	arrays consisting of key/value pairs of `objectId`. These are called Pointers
	in `Parse`.
	If you want to retrieve the complete object pointed to in `book`, you need to add
	the field names containing the objects specifically in `include` in your query.
	*/
	/*:
	Here, we include `book`. If you wanted `book` and `otherBook`, you
	could have used: `.include(["book", "otherBook"])`.
	*/
	let query2 = Author.query("name" == "Bruce")
	.include("book")
	query2.first { results in
	switch results {
	case .success(let author):
	//: Save the book to use later
	if let book = author.book {
	newBook = book
	}
	print("Found author and included \"book\": \(author)")
	case .failure(let error):
	assertionFailure("Error querying: \(error)")
	}
	}
	/*:
	When you have many fields that are pointing to objects, it may become tedious
	to add all of them to the list. You can quickly retreive all pointer objects by
	using `includeAll`. You can also use `include("*")` to retrieve all pointer
	objects.
	*/
	let query3 = Author.query("name" == "Bruce")
	.includeAll()
	query3.first { results in
	switch results {
	case .success(let author):
	print("Found author and included all: \(author)")
	case .failure(let error):
	assertionFailure("Error querying: \(error)")
	}
	}
	//: You can also check if a field is equal to a ParseObject.
	do {
	let query4 = try Author.query("book" == newBook)
	.includeAll()
	query4.first { results in
	switch results {
	case .success(let author):
	print("Found author and included all: \(author)")
	case .failure(let error):
	assertionFailure("Error querying: \(error)")
	}
	}
	} catch {
	print("\(error)")
	}
	//: Here's an example of saving Pointers as properties.
	do {
	//: First we query
	let query5 = try Author.query("book" == newBook)
	.include("book")
	query5.first { results in
	switch results {
	case .success(let author):

[project-saf]

Perhaps I'm misunderstanding, but the playground didn't really help.
However, I think I have the answer, but would appreciate your thoughts.

Say I have a Parse Class called Movie, and one called Actor, as so:

public struct Movie: ParseObject {
    // ...
    // default variables
    // ...
    public var movieName: String?
    public var leadActor: Pointer<Actor>?
}

public struct Actor: ParseObject {
    // ...
    // default variables
    // ...
    public var actorName: String?
    public var mostFamousMovie: Pointer<Movie>?
}

If I ran a query on the Movie table, for example, where movieName contains "James Bond", I'll get an array of Movies.
If I wanted to get a list of the leadActor's, is the best way to do that via getting an array of pointers, and then convert that to an array of objects, and run fetchAll()?
For example:

guard let movies = try? await query.find()
else { return }

let pointers = movies.compactMap(\.leadActor)
let actors: Array<Actor> = pointers.map { $0.toObject() }
// I know I could have also done:
// let actors: Array<Actor> = movies.compactMap { $0.leadActor?.toObject() }
guard let fetchedActors = try? await actors.fetchAll()
else { return }

Is this the best/most efficient way to do this?

When I first wrote the question, I was thinking I had to loop over the array of Movie, and then call fetch() on each leadActor pointer.

guard let movies = try? await query.fetch()
else { throw /*some Error*/ }

var actors: Array<Actor> = []
for movie in movies {
    guard let actor = try? await movie.leadActor?.fetch()
    else { continue }
    actors.append(actor)
}

Because I noticed there was no fetchAll() method on Array<Pointer<Movie>>, in the same way that there was one defined on Array<Movie>, which is where my question originated from.

[cbaker6]

Yes, using compactMap toObject and then fetchAll is fine. If you submit a PR using map toObject to enable fetchAll for pointers, I’ll review it

[cbaker6]

The playgrounds examples shows you don’t need Pointer<Actor>, instead

public struct Movie: ParseObject {
// ...
// default variables
// ...
public var movieName: String?
public var leadActor: Actor?
public var actors: [Actor]?
}

And then query with fetching all to get everything at once.

[project-saf]

Yes, but I wouldn't be able to define Actor with the property mostFamousMovie being of type Movie, due to recursive referencing.

[cbaker6]

My answer to this is same as before #109 (comment)

[project-saf]

I am aware...that's my entire point.
Don't worry about it

[project-saf]

Okay, thanks for your thoughts