arrow_schema/
error.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18//! Defines `ArrowError` for representing failures in various Arrow operations.
19use std::fmt::{Debug, Display, Formatter};
20use std::io::Write;
21
22use std::error::Error;
23
24/// Many different operations in the `arrow` crate return this error type.
25#[derive(Debug)]
26pub enum ArrowError {
27    /// Returned when functionality is not yet available.
28    NotYetImplemented(String),
29    /// Wraps an external error.
30    ExternalError(Box<dyn Error + Send + Sync>),
31    /// Error during casting from one type to another.
32    CastError(String),
33    /// Memory or buffer error.
34    MemoryError(String),
35    /// Error during parsing from a string.
36    ParseError(String),
37    /// Error during schema-related operations.
38    SchemaError(String),
39    /// Error during computation.
40    ComputeError(String),
41    /// Error during division by zero.
42    DivideByZero,
43    /// Error when an arithmetic operation overflows.
44    ArithmeticOverflow(String),
45    /// Error during CSV-related operations.
46    CsvError(String),
47    /// Error during JSON-related operations.
48    JsonError(String),
49    /// Error during IO operations.
50    IoError(String, std::io::Error),
51    /// Error during IPC operations in `arrow-ipc` or `arrow-flight`.
52    IpcError(String),
53    /// Error indicating that an unexpected or bad argument was passed to a function.
54    InvalidArgumentError(String),
55    /// Error during Parquet operations.
56    ParquetError(String),
57    /// Error during import or export to/from the C Data Interface
58    CDataInterface(String),
59    /// Error when a dictionary key is bigger than the key type
60    DictionaryKeyOverflowError,
61    /// Error when the run end index in a REE array is bigger than the array length
62    RunEndIndexOverflowError,
63}
64
65impl ArrowError {
66    /// Wraps an external error in an `ArrowError`.
67    pub fn from_external_error(error: Box<dyn Error + Send + Sync>) -> Self {
68        Self::ExternalError(error)
69    }
70}
71
72impl From<std::io::Error> for ArrowError {
73    fn from(error: std::io::Error) -> Self {
74        ArrowError::IoError(error.to_string(), error)
75    }
76}
77
78impl From<std::str::Utf8Error> for ArrowError {
79    fn from(error: std::str::Utf8Error) -> Self {
80        ArrowError::ParseError(error.to_string())
81    }
82}
83
84impl From<std::string::FromUtf8Error> for ArrowError {
85    fn from(error: std::string::FromUtf8Error) -> Self {
86        ArrowError::ParseError(error.to_string())
87    }
88}
89
90impl<W: Write> From<std::io::IntoInnerError<W>> for ArrowError {
91    fn from(error: std::io::IntoInnerError<W>) -> Self {
92        ArrowError::IoError(error.to_string(), error.into())
93    }
94}
95
96impl Display for ArrowError {
97    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
98        match self {
99            ArrowError::NotYetImplemented(source) => {
100                write!(f, "Not yet implemented: {}", &source)
101            }
102            ArrowError::ExternalError(source) => write!(f, "External error: {}", &source),
103            ArrowError::CastError(desc) => write!(f, "Cast error: {desc}"),
104            ArrowError::MemoryError(desc) => write!(f, "Memory error: {desc}"),
105            ArrowError::ParseError(desc) => write!(f, "Parser error: {desc}"),
106            ArrowError::SchemaError(desc) => write!(f, "Schema error: {desc}"),
107            ArrowError::ComputeError(desc) => write!(f, "Compute error: {desc}"),
108            ArrowError::ArithmeticOverflow(desc) => write!(f, "Arithmetic overflow: {desc}"),
109            ArrowError::DivideByZero => write!(f, "Divide by zero error"),
110            ArrowError::CsvError(desc) => write!(f, "Csv error: {desc}"),
111            ArrowError::JsonError(desc) => write!(f, "Json error: {desc}"),
112            ArrowError::IoError(desc, _) => write!(f, "Io error: {desc}"),
113            ArrowError::IpcError(desc) => write!(f, "Ipc error: {desc}"),
114            ArrowError::InvalidArgumentError(desc) => {
115                write!(f, "Invalid argument error: {desc}")
116            }
117            ArrowError::ParquetError(desc) => {
118                write!(f, "Parquet argument error: {desc}")
119            }
120            ArrowError::CDataInterface(desc) => {
121                write!(f, "C Data interface error: {desc}")
122            }
123            ArrowError::DictionaryKeyOverflowError => {
124                write!(f, "Dictionary key bigger than the key type")
125            }
126            ArrowError::RunEndIndexOverflowError => {
127                write!(f, "Run end encoded array index overflow error")
128            }
129        }
130    }
131}
132
133impl Error for ArrowError {
134    fn source(&self) -> Option<&(dyn Error + 'static)> {
135        match self {
136            ArrowError::ExternalError(source) => Some(source.as_ref()),
137            ArrowError::IoError(_, source) => Some(source),
138            _ => None,
139        }
140    }
141}
142
143#[cfg(test)]
144mod test {
145    use super::*;
146
147    #[test]
148    fn error_source() {
149        let e1 = ArrowError::DivideByZero;
150        assert!(e1.source().is_none());
151
152        // one level of wrapping
153        let e2 = ArrowError::ExternalError(Box::new(e1));
154        let source = e2.source().unwrap().downcast_ref::<ArrowError>().unwrap();
155        assert!(matches!(source, ArrowError::DivideByZero));
156
157        // two levels of wrapping
158        let e3 = ArrowError::ExternalError(Box::new(e2));
159        let source = e3
160            .source()
161            .unwrap()
162            .downcast_ref::<ArrowError>()
163            .unwrap()
164            .source()
165            .unwrap()
166            .downcast_ref::<ArrowError>()
167            .unwrap();
168
169        assert!(matches!(source, ArrowError::DivideByZero));
170    }
171}
arrow_schema/error.rs

arrow_schema/
error.rs
