lance-nd 0.1.0

N-dimensional datasets stored in Lance, one dataset or chunk per row
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Error type for lance-nd.

use std::sync::Arc;

use arrow::error::ArrowError;
use nd_arrow_array::NdError;

/// Errors raised by lance-nd.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum Error {
    /// An error from the nd array encoding.
    #[error(transparent)]
    Nd(#[from] NdError),
    /// An error from Lance.
    #[error(transparent)]
    Lance(Box<lance::Error>),
    /// An error from Arrow.
    #[error(transparent)]
    Arrow(#[from] ArrowError),
    /// Variable names or types do not match.
    #[error("schema mismatch: {0}")]
    SchemaMismatch(String),
    /// The Lance dataset does not follow the nd-arrow encoding, or has
    /// another format version.
    #[error("invalid table: {0}")]
    InvalidTable(String),
    /// An argument is not valid.
    #[error("invalid argument: {0}")]
    InvalidArgument(String),
    /// No table exists at the uri.
    #[error("no table at {0}")]
    TableNotFound(String),
    /// A table exists at the uri.
    #[error("a table exists at {0}")]
    TableExists(String),
    /// Another commit changed the table first. When `retryable` is `true`,
    /// the same operation can succeed when you try it again.
    #[error("commit conflict: {source}")]
    CommitConflict {
        /// `true` when a new try can succeed.
        retryable: bool,
        /// The Lance error.
        source: Box<lance::Error>,
    },
    /// A write of an [`crate::NdWriter`] failed, so the writer commits nothing.
    #[error("the writer failed, nothing is committed: {0}")]
    WriterFailed(#[source] Arc<Error>),
    /// A fragment write task stopped without a result.
    #[error("a fragment write stopped: {0}")]
    TaskFailed(#[from] tokio::task::JoinError),
}

impl From<lance::Error> for Error {
    fn from(error: lance::Error) -> Self {
        match error {
            lance::Error::DatasetNotFound { path, .. } => Self::TableNotFound(path),
            lance::Error::DatasetAlreadyExists { uri, .. } => Self::TableExists(uri),
            lance::Error::CommitConflict { .. }
            | lance::Error::RetryableCommitConflict { .. }
            | lance::Error::TooMuchWriteContention { .. } => Self::CommitConflict {
                retryable: true,
                source: Box::new(error),
            },
            lance::Error::IncompatibleTransaction { .. } => Self::CommitConflict {
                retryable: false,
                source: Box::new(error),
            },
            error => Self::Lance(Box::new(error)),
        }
    }
}

/// A result with [`Error`] as the default error.
pub type Result<T, E = Error> = std::result::Result<T, E>;