substrait-explain 0.3.1

Explain Substrait plans as human-readable text.
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

use thiserror::Error;

use super::MessageParseError;
use super::extensions::ExtensionParseError;
use crate::extensions::registry::ExtensionError;

/// Context for parse errors and warnings
#[derive(Debug, Clone)]
pub struct ParseContext {
    pub line_no: i64,
    pub line: String,
}

impl ParseContext {
    pub fn new(line_no: i64, line: String) -> Self {
        Self { line_no, line }
    }
}

impl std::fmt::Display for ParseContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "line {}: '{}'", self.line_no, self.line)
    }
}

/// Parse errors that prevent successful parsing
#[derive(Debug, Clone, Error)]
pub enum ParseError {
    #[error("Error parsing extension on {0}: {1}")]
    Extension(ParseContext, #[source] ExtensionParseError),

    #[error("Error parsing extension detail on {0}: {1}")]
    ExtensionDetail(ParseContext, #[source] ExtensionError),

    #[error("Error parsing plan on {0}: {1}")]
    Plan(ParseContext, #[source] MessageParseError),

    #[error("Expected '{expected}' on {context}")]
    Expected {
        expected: &'static str,
        context: ParseContext,
    },

    #[error("No relation found in plan")]
    NoRelationFound,

    #[error("Unregistered extension '{name}' on {context}")]
    UnregisteredExtension { name: String, context: ParseContext },

    #[error("Failed to parse relation on {0}: {1}")]
    RelationParse(ParseContext, String),

    #[error("Unknown extension relation type: {0}")]
    UnknownExtensionRelationType(String),

    #[error("Validation error: {0}")]
    ValidationError(String),

    #[error("Error parsing section header on line {0}: {1}")]
    Initial(ParseContext, #[source] MessageParseError),

    #[error("Error parsing relation: {0}")]
    Relation(ParseContext, #[source] MessageParseError),
}

/// Result type for the public Parser API
pub type ParseResult = Result<substrait::proto::Plan, ParseError>;