Struct async_graphql::dataloader::DataLoader

pub struct DataLoader<T, C = NoCache> { /* fields omitted */ }

This is supported on crate feature dataloader only.

Data loader.

Reference: https://github.com/facebook/dataloader

Implementations

impl<T> DataLoader<T, NoCache>

pub fn new<S, R>(loader: T, spawner: S) -> Self where
    S: Fn(BoxFuture<'static, ()>) -> R + Send + Sync + 'static, 

Use Loader to create a DataLoader that does not cache records.

impl<T, C: CacheFactory> DataLoader<T, C>

pub fn with_cache<S, R>(loader: T, spawner: S, cache_factory: C) -> Self where
    S: Fn(BoxFuture<'static, ()>) -> R + Send + Sync + 'static, 

Use Loader to create a DataLoader with a cache factory.

pub fn delay(self, delay: Duration) -> Self

Specify the delay time for loading data, the default is 1ms.

pub fn max_batch_size(self, max_batch_size: usize) -> Self

pub fn Specify the max batch size for loading data, the default is 1000.

If the keys waiting to be loaded reach the threshold, they are loaded immediately.

pub fn loader(&self) -> &T

Get the loader.

pub fn enable_all_cache(&self, enable: bool)

Enable/Disable cache of all loaders.

pub fn enable_cache<K>(&self, enable: bool) where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    T: Loader<K>, 

Enable/Disable cache of specified loader.

pub async fn load_one<K>(&self, key: K) -> Result<Option<T::Value>, T::Error> where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    T: Loader<K>, 

Use this DataLoader load a data.

pub async fn load_many<K, I>(
    &self,
    keys: I
) -> Result<HashMap<K, T::Value>, T::Error> where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    I: IntoIterator<Item = K>,
    T: Loader<K>, 

Use this DataLoader to load some data.

pub async fn feed_many<K, I>(&self, values: I) where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    I: IntoIterator<Item = (K, T::Value)>,
    T: Loader<K>, 

Feed some data into the cache.

**NOTE: If the cache type is NoCache, this function will not take effect. **

pub async fn feed_one<K>(&self, key: K, value: T::Value) where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    T: Loader<K>, 

Feed some data into the cache.

**NOTE: If the cache type is NoCache, this function will not take effect. **

pub fn clear<K>(&self) where
    K: Send + Sync + Hash + Eq + Clone + 'static,
    T: Loader<K>, 

Clears the cache.

**NOTE: If the cache type is NoCache, this function will not take effect. **