Idea: Asynchronous fetching #73

New Issue

adam · 2025-12-29T15:23:39+01:00

adam commented

2025-12-29 15:23:39 +01:00

Originally created by @JohnEstropia on GitHub (Aug 26, 2016).

Objective: allow a way to fetch objects in a way that can wait for completion of

Store migrations (need to explicitly provide configuration in Into<Entity>("...") clause)
Heavy queries

Originally created by @JohnEstropia on GitHub (Aug 26, 2016). Objective: allow a way to fetch objects in a way that can wait for completion of 1. Store migrations (need to explicitly provide configuration in `Into<Entity>("...")` clause) 2. Heavy queries

adam added the enhancement label 2025-12-29 15:23:39 +01:00

adam commented

2025-12-29 15:23:39 +01:00

@flyingcane commented on GitHub (Dec 27, 2017):

@JohnEstropia Hi JohnEstropia, it's a great open source for core data. Does CoreStore only support fetch records on the main thread? If a large number of records, does it block the main thread?

@flyingcane commented on GitHub (Dec 27, 2017): @JohnEstropia Hi JohnEstropia, it's a great open source for core data. Does CoreStore only support fetch records on the main thread? If a large number of records, does it block the main thread?

adam commented

2025-12-29 15:23:40 +01:00

@JohnEstropia commented on GitHub (Dec 27, 2017):

@evanxie-cn If you have very large fetches (e.g. image binary data, few thousand objects) you can always fetch from a background transaction and pass the info you need to the main thread. Here's an example:

dataStack.perform(
    asynchronous: { (transaction) -> [UIImage] in
        let people = transaction.fetchAll(From<Person>().where(/* ... */))
        return people.map { UIImage(data: $0.imageData)! }
    },
    completion: { (photos) in  /* ... */
        // use photos
    }
)

Depending on your confidence on your app architecture, you can also use unsafe transactions (dataStack.beginUnsafe()) in conjunction with your own DispatchQueues.

@JohnEstropia commented on GitHub (Dec 27, 2017): @evanxie-cn If you have very large fetches (e.g. image binary data, few thousand objects) you can always fetch from a background transaction and pass the info you need to the main thread. Here's an example: ```swift dataStack.perform( asynchronous: { (transaction) -> [UIImage] in let people = transaction.fetchAll(From<Person>().where(/* ... */)) return people.map { UIImage(data: $0.imageData)! } }, completion: { (photos) in /* ... */ // use photos } ) ``` Depending on your confidence on your app architecture, you can also use unsafe transactions (`dataStack.beginUnsafe()`) in conjunction with your own `DispatchQueue`s.

adam commented

2025-12-29 15:23:40 +01:00

@flyingcane commented on GitHub (Dec 28, 2017):

@JohnEstropia Thank you very much. I got it.

@flyingcane commented on GitHub (Dec 28, 2017): @JohnEstropia Thank you very much. I got it.

Sign in to join this conversation.

Branches Tags

develop

master

prototype/concurrency

minIOS13

prototype/containers

transactionSourceTracking

prototype/swiftui

minIOS11

swift5_3

prototype/propertyWrapperFields

prototype/propertyWrappers

prototype/propertyWrapper

Swift5

throwables

prototype/Swift_4_1

prototype/Swift_4_0

prototype/Swift_3_2

prototype/queryBuilders

temp/develop

corestore4_develop

prototype/mainContextToPSC

master_ios_7_to_9

swift_2_3

gh-pages

_corespotlight-test

1 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: starred/CoreStore#73