graphfusion 0.2.0

GraphFusion graph database.
Documentation
use std::{fmt, io, path::PathBuf};

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    Parse(gql_parser::Error),
    DataFusion(Box<datafusion::error::DataFusionError>),
    InvalidQuery(String),
    Io(io::Error),
    Corrupt(String),
    UnsupportedFeature(String),
    AlreadyExists(String),
    NotFound(String),
    InvalidDefinition(String),
    DependencyExists(String),
    Conflict(String),
    InvalidReference(String),
    SessionClosed,
    TransactionActive,
    NoTransaction,
    TransactionFailed,
    ReadOnlyTransaction,
    Busy,
    DatabaseInUse(PathBuf),
    CommitUnknown(io::Error),
    Poisoned,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Parse(e) => write!(f, "{e}"),
            Self::DataFusion(e) => write!(f, "query execution error: {e}"),
            Self::InvalidQuery(s) => write!(f, "invalid query: {s}"),
            Self::Io(e) => write!(f, "I/O error: {e}"),
            Self::Corrupt(s) => write!(f, "corrupt database: {s}"),
            Self::UnsupportedFeature(s) => write!(f, "unsupported feature: {s}"),
            Self::AlreadyExists(s) => write!(f, "already exists: {s}"),
            Self::NotFound(s) => write!(f, "not found: {s}"),
            Self::InvalidDefinition(s) => write!(f, "invalid definition: {s}"),
            Self::DependencyExists(s) => write!(f, "dependent objects exist: {s}"),
            Self::Conflict(s) => write!(f, "transaction conflict: {s}"),
            Self::InvalidReference(s) => write!(f, "invalid reference: {s}"),
            Self::SessionClosed => write!(f, "session is closed"),
            Self::TransactionActive => write!(f, "a transaction is already active"),
            Self::NoTransaction => write!(f, "no explicit transaction is active"),
            Self::TransactionFailed => write!(f, "transaction is failed; ROLLBACK is required"),
            Self::ReadOnlyTransaction => {
                write!(f, "writes are forbidden in a READ ONLY transaction")
            }
            Self::Busy => write!(f, "active statements or transactions prevent checkpoint"),
            Self::DatabaseInUse(path) => write!(f, "database is already open in another process: {}", path.display()),
            Self::CommitUnknown(e) => {
                write!(f, "commit outcome is unknown; reopen before retrying: {e}")
            }
            Self::Poisoned => write!(f, "database coordinator is poisoned; drop all database and session handles before reopening"),
        }
    }
}

impl std::error::Error for Error {}
impl From<datafusion::error::DataFusionError> for Error {
    fn from(e: datafusion::error::DataFusionError) -> Self {
        Self::DataFusion(Box::new(e))
    }
}
impl From<io::Error> for Error {
    fn from(e: io::Error) -> Self {
        Self::Io(e)
    }
}
impl From<gql_parser::Error> for Error {
    fn from(e: gql_parser::Error) -> Self {
        Self::Parse(e)
    }
}
impl From<serde_json::Error> for Error {
    fn from(e: serde_json::Error) -> Self {
        Self::Corrupt(e.to_string())
    }
}