Recommended fetch strategy

[pahnev]

The documentation and examples use the @FetchAll, @FetchOne and @Fetch property wrappers directly. Is that the recommended way? Is there some way to have e.g. a wrapper class that deals with the sqlite-data and just exposes the types without losing the nice things from the library?

It seems that when doing something like this, we lose the ability e.g. to observe the changes of the return type.

class Wrapper {
  func fetchReminder(id: String) -> Reminder {
    @FetchAll(
      Reminder.where({ $0.id == id })
    )
    var reminder
    return reminder
  }
}

[stephencelis]

The @FetchAll, @FetchOne and @Fetch property wrappers set up database observation to automatically subscribe SwiftUI views (or anything using Swift observation) to their changes.

If you're not needing to subscribe to changes, we recommend executing queries directly:

@Dependency(\.defaultDatabase) var database
let reminder = try database.read { db in
  try Reminder.find(id).fetchOne(db)
}
reminder  // Reminder?

Let us know if there's a part of the docs you were looking at that we could improve!

[pahnev]

property wrappers set up database observation to automatically

I think I was wondering if there's any other way to achieve the same.

In my use case I'm not doing these fetches in SwiftUI views. I'd also like to avoid sprinkling these and more complex fetches all over the code base and just have a way to access the observable value fetched.

[mbrandonw]

Hi @pahnev, there are a number of approaches to this, but we personally feel like these kinds of wrapper objects to hide the database from your codebase aren't worth the effort.

If you really want the wrapper to work for you, you will need it to return FetchOne/FetchAll/Fetch types, not just the data, so that you can retain observability. Here is an example of a SwiftUI view that gets its @FetchOne var reminder from a wrapper object like you outlined above:

class Wrapper {
  func reminder(id: UUID) -> FetchOne<Reminder?> {
    FetchOne(Reminder.where { $0.id.eq(id) })
  }
}

import SwiftUI
struct ReminderDetailView: View {
  @FetchOne var reminder: Reminder?
  init(id: UUID, wrapper: Wrapper) {
    _reminder = wrapper.reminder(id: id)
  }
  …
}

That hides (most) of the details of the query in Wrapper while allowing you to access the @FetchOne property wrapper that powers observability.

But, if you are just wanting to hide the details of complex queries and share queries across multiple screens, there are better ways. You can define reusable queries directly on your table:

extension Reminder {
  static let important = Reminder
    .where { $0.priority.eq(Priority.high) && !$0.isCompleted }
    .order(by: \.dueDate)
}

And then you can use this with @FetchAll anywhere:

struct ImportantRemindersView: View {
  @FetchAll(Reminder.important) var reminders
  …
}

We've got docs on this technique (and more) here.

And an even better technique would be to define custom database views that package up the results of a complex query that you can then query itself as if it were a regular table. We have docs on that here.