Skip to main content

spark_ddl_parser/
error.rs

1//! Parse errors for DDL schema parser.
2//!
3//! Error messages are aligned with the Python package's ValueError text where practical.
4
5use std::fmt;
6
7/// Result type for DDL parsing.
8pub type Result<T> = std::result::Result<T, ParseError>;
9
10/// Errors that can occur when parsing a DDL schema string.
11#[derive(Clone, Debug, PartialEq, Eq)]
12pub enum ParseError {
13    /// Unbalanced angle brackets: extra '>'
14    UnbalancedAngleBracketsExtraClose,
15    /// Unbalanced angle brackets: missing '>'
16    UnbalancedAngleBracketsMissingClose,
17    /// Unbalanced parentheses: extra ')'
18    UnbalancedParensExtraClose,
19    /// Unbalanced parentheses: missing ')'
20    UnbalancedParensMissingClose,
21    /// Invalid field definition: comma at start
22    CommaAtStart,
23    /// Invalid field definition: trailing comma
24    TrailingComma,
25    /// Invalid field definition: double comma
26    DoubleComma,
27    /// Invalid struct type (e.g. struct< without matching >)
28    InvalidStructType(String),
29    /// Invalid field definition with context
30    InvalidFieldDefinition(String),
31    /// Invalid type: empty type string
32    EmptyTypeString,
33    /// Invalid decimal type
34    InvalidDecimalType(String),
35    /// Invalid array type
36    InvalidArrayType(String),
37    /// Invalid map type
38    InvalidMapType(String),
39}
40
41impl fmt::Display for ParseError {
42    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
43        match self {
44            ParseError::UnbalancedAngleBracketsExtraClose => {
45                write!(f, "Unbalanced angle brackets: extra '>'")
46            }
47            ParseError::UnbalancedAngleBracketsMissingClose => {
48                write!(f, "Unbalanced angle brackets: missing '>'")
49            }
50            ParseError::UnbalancedParensExtraClose => {
51                write!(f, "Unbalanced parentheses: extra ')'")
52            }
53            ParseError::UnbalancedParensMissingClose => {
54                write!(f, "Unbalanced parentheses: missing ')'")
55            }
56            ParseError::CommaAtStart => {
57                write!(f, "Invalid field definition: comma at start")
58            }
59            ParseError::TrailingComma => {
60                write!(f, "Invalid field definition: trailing comma")
61            }
62            ParseError::DoubleComma => {
63                write!(f, "Invalid field definition: double comma")
64            }
65            ParseError::InvalidStructType(s) => {
66                write!(f, "Invalid struct type: {}", s)
67            }
68            ParseError::InvalidFieldDefinition(s) => {
69                write!(f, "Invalid field definition: {}", s)
70            }
71            ParseError::EmptyTypeString => {
72                write!(f, "Invalid type: empty type string")
73            }
74            ParseError::InvalidDecimalType(s) => {
75                write!(f, "Invalid decimal type: {}", s)
76            }
77            ParseError::InvalidArrayType(s) => {
78                write!(f, "Invalid array type: {}", s)
79            }
80            ParseError::InvalidMapType(s) => {
81                write!(f, "Invalid map type: {}", s)
82            }
83        }
84    }
85}
86
87impl std::error::Error for ParseError {}