Struct DatasetView 

pub struct DatasetView { /* private fields */ }

A borrowed handle to one dataset within an Atlas.

Carries no independent state — every mutation (define_array, write_array, set_attribute, delete_array) updates the parent atlas’s shared in-memory metadata. Persistence happens when the parent Atlas::flush is called; DatasetView has no flush of its own.

DatasetView is Send and can be moved across tasks, but holding many concurrent views to the same dataset and mutating from each is not protected — the underlying lock is on the shared metadata, not per-view.

Implementations

impl DatasetView

pub fn meta(&self) -> DatasetMeta

Returns a clone of the metadata for this dataset.

pub fn name(&self) -> &str

The dataset name this view points to.

pub fn list_arrays(&self) -> Vec<String>

All array names declared in this dataset, in insertion order. Reads from the shared in-memory meta — no disk I/O.

pub fn set_attribute(&mut self, key: &str, value: Attr)

Set or overwrite a typed attribute on this dataset. Buffered in the in-memory meta until the parent Atlas::flush.

pub fn get_attribute(&self, key: &str) -> Option<Attr>

Look up an attribute by key. None if the key isn’t present (or the dataset has no attributes at all yet).

pub fn array_meta(&self, array: &str) -> Option<ArraySchema>

Returns the cached schema for array, or None if no array with that name exists in this dataset.

pub async fn array_stats(&self, array: &str) -> Option<ArrayStats>

Returns aggregate statistics for array in this dataset, or None if no such array exists or stats haven’t been computed yet (stats are computed on flush).

pub async fn define_array<T: ArrayElement>( &mut self, array: &str, dims: Vec<String>, shape: Vec<usize>, chunk_shape: Option<Vec<usize>>, fill_value: Option<FillValue>, ) -> Result<()>

Declare a new array in this dataset.

dims are named dimensions (one per axis); shape is the logical size per axis. chunk_shape = None means one chunk per axis (a single block per dataset entry — fastest write for small arrays; pessimal for slice reads on large arrays). fill_value is the scalar returned for unwritten cells; cells equal to it are tallied as nulls in array_stats after Atlas::flush.

Errors with Error::ArrayAlreadyExists if this dataset already declares an array with that name, or Error::InvalidName if array violates the naming rules.

pub async fn write_array<T: ArrayElement>( &mut self, array: &str, start: Vec<usize>, data: ArrayView<'_, T, IxDyn>, ) -> Result<()>

Write a slab of values into an array previously declared via define_array.

start is the per-axis offset to begin writing at; data’s shape determines the extent. Out-of-bounds writes truncate at the array’s declared shape. The bytes are buffered in the per-array in-memory layer; nothing reaches disk until Atlas::flush.

Errors with Error::ArrayNotFound if no array with this name has been declared.

pub async fn read_array<T: ArrayElement>( &self, array: &str, start: Vec<usize>, shape: Vec<usize>, ) -> Result<Option<ArcArray<T, IxDyn>>>

Read a full or partial array from this dataset.

Empty start + empty shape reads the full array. Otherwise both must have one entry per dimension; only chunks overlapping the requested region are decompressed.

Returns Ok(None) if this dataset doesn’t declare an array with that name.

Examples

use atlas::{Atlas, StoreConfig};
use ndarray::Array2;
let tmp = tempfile::tempdir().unwrap();
let mut s = Atlas::create_path(tmp.path(), StoreConfig::default()).await.unwrap();
{
    let mut ds = s.create_dataset("ds").await.unwrap();
    ds.define_array::<f32>("temp", vec!["x".into(), "y".into()],
                           vec![4, 8], None, None).await.unwrap();
    let data = Array2::<f32>::from_elem([4, 8], 9.0).into_dyn();
    ds.write_array("temp", vec![0, 0], data.view()).await.unwrap();

    // Full read.
    let full = ds.read_array::<f32>("temp", vec![], vec![]).await.unwrap().unwrap();
    assert_eq!(full.shape(), &[4, 8]);

    // Partial read — a 2×4 sub-region.
    let part = ds.read_array::<f32>("temp", vec![1, 2], vec![2, 4]).await.unwrap().unwrap();
    assert_eq!(part.shape(), &[2, 4]);
}
s.flush().await.unwrap();

pub async fn array_fill_value(&self, array: &str) -> Result<Option<FillValue>>

Returns the fill value passed to define_array for array, or None if the array isn’t present in this dataset or was defined without one.

pub async fn delete_array(&mut self, array: &str) -> Result<()>

Remove an array from this dataset. Tombstones the dataset’s entry inside the shared array file; persistence happens on the next Atlas::flush. Errors with Error::ArrayNotFound if no array with that name is declared here.