Struct DatasetClient 

pub struct DatasetClient { /* private fields */ }

Client for a specific dataset.

Implementations

impl DatasetClient

pub async fn get(&self) -> ApifyClientResult<Option<Dataset>>

Fetches the dataset metadata, or None if it does not exist.

pub async fn update<T: Serialize>( &self, new_fields: &T, ) -> ApifyClientResult<Dataset>

Updates the dataset metadata (e.g. name, title).

pub async fn delete(&self) -> ApifyClientResult<()>

Deletes the dataset.

pub async fn list_items<T: DeserializeOwned>( &self, options: DatasetListItemsOptions, ) -> ApifyClientResult<PaginationList<T>>

Lists items from the dataset.

The dataset items endpoint returns a bare JSON array (not a data envelope) and reports pagination via X-Apify-Pagination-* headers, which are surfaced in the returned PaginationList.

pub fn iterate_items<T: DeserializeOwned + Send + 'static>( &self, options: DatasetListItemsOptions, ) -> ListIterator<T>

Lazily iterates over all items in the dataset, fetching pages on demand.

The idiomatic-Rust counterpart of the reference client’s async-iterable listItems/iterateItems: yields one deserialized item of type T at a time, transparently paging. The caller’s options.limit caps the total number of items yielded (unset = all); use ListIterator::with_chunk_size to control the per-page fetch size.

Server-side filters (skip_empty/clean/skip_hidden) and unwind are forwarded on every page request. Paging advances the offset by the number of underlying rows each page scanned (the x-apify-pagination-count response header), not by items.len(), matching the reference JavaScript client: a filter can scan more rows than it returns, and unwind can return more items than rows scanned, so advancing by the returned count alone would re-scan or skip rows. The listing’s reported total is never consulted, so a dataset a still-running Actor keeps pushing to is read to the end: iteration keeps requesting pages until one scans no rows (one extra, empty request past the last page with data), rather than stopping at the size the dataset had when the loop started.

If x-apify-pagination-count is ever absent, the scanned count falls back to items.len().

pub async fn download_items( &self, format: DownloadItemsFormat, options: DatasetDownloadOptions, ) -> ApifyClientResult<Vec<u8>>

Downloads dataset items serialized in the given format, returning the raw bytes.

Unlike list_items, which returns parsed items, this returns the items already serialized to JSON, CSV, XLSX, XML, RSS or HTML — useful for exporting. Use DatasetDownloadOptions to control export-specific behaviour (BOM, CSV delimiter/header, XML element names, attachment disposition).

pub async fn download_items_stream( &self, format: DownloadItemsFormat, options: DatasetDownloadOptions, ) -> ApifyClientResult<impl Stream<Item = ApifyClientResult<Vec<u8>>>>

Like download_items, but streams the export as it arrives instead of buffering the whole response in memory.

Returns a Stream of byte chunks; drive it with futures_util::StreamExt::next() (or pipe it through an AsyncRead adapter) to process a large export in constant memory. A gap of more than 6 minutes between chunks ends the stream with ApifyClientError::Timeout — an inactivity timeout, not a cap on the export’s total duration.

Goes through the configured HttpBackend’s streaming path instead of the buffered one, to keep the connection open — like crate::clients::log::LogClient::stream, a failed request (e.g. a 404) still surfaces the same structured crate::error::ApiError as the buffered endpoints, from reading the error body before the stream is handed back.

pub async fn push_items<T: Serialize>(&self, items: &T) -> ApifyClientResult<()>

Pushes one or more items to the dataset.

items must serialize to a JSON object or an array of objects.

pub async fn create_items_public_url( &self, options: DatasetListItemsOptions, expires_in_secs: Option<i64>, ) -> ApifyClientResult<String>

Builds a public URL for downloading this dataset’s items.

Mirrors the reference client’s createItemsPublicUrl: it fetches the dataset, and if the dataset exposes a URL-signing secret key (i.e. it is private), appends an HMAC-SHA256 signature so the URL grants access without an API token. expires_in_secs optionally bounds the validity of a signed URL. The URL is built from the configured public base URL. The served items are JSON; to request another export format, use create_items_public_url_with_format.

pub async fn create_items_public_url_with_format( &self, options: DatasetListItemsOptions, expires_in_secs: Option<i64>, format: Option<DownloadItemsFormat>, ) -> ApifyClientResult<String>

Like create_items_public_url, but lets the caller choose the format the items are served in (JSON, CSV, XLSX, …) via a format query parameter on the generated URL. None defaults to json, matching the endpoint’s own default.

pub async fn get_statistics(&self) -> ApifyClientResult<Option<Value>>

Returns statistical information about the dataset, or None if unavailable.

Trait Implementations

impl Clone for DatasetClient

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DatasetClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.