substrait 0.63.0

Cross-Language Serialization for Relational Algebra
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// SPDX-License-Identifier: Apache-2.0

//! Parsing of [proto::extensions::SimpleExtensionUrn].

use std::str::FromStr;

use thiserror::Error;

use crate::{
    parse::{Anchor, Parse, context::ContextError, proto::ExtensionAnchors},
    proto,
    urn::{InvalidUrn, Urn},
};

/// A parsed [proto::extensions::SimpleExtensionUrn].
#[derive(Clone, Debug, PartialEq)]
pub struct SimpleExtensionUrn {
    /// The urn of this simple extension.
    urn: Urn,

    /// The anchor value of this simple extension.
    anchor: Anchor<Self>,
}

impl SimpleExtensionUrn {
    /// Returns the urn of this simple extension.
    ///
    /// See [proto::extensions::SimpleExtensionUrn::urn].
    pub fn urn(&self) -> &Urn {
        &self.urn
    }

    /// Returns the anchor value of this simple extension.
    ///
    /// See [proto::extensions::SimpleExtensionUrn::extension_urn_anchor].
    pub fn anchor(&self) -> Anchor<Self> {
        self.anchor
    }
}

/// Parse errors for [proto::extensions::SimpleExtensionUrn].
#[derive(Debug, Error, PartialEq)]
pub enum SimpleExtensionUrnError {
    /// Invalid Urn
    #[error("invalid urn")]
    InvalidUrn(#[from] InvalidUrn),

    /// Context error
    #[error(transparent)]
    Context(#[from] ContextError),
}

impl Parse<ExtensionAnchors> for proto::extensions::SimpleExtensionUrn {
    type Parsed = SimpleExtensionUrn;
    type Error = SimpleExtensionUrnError;

    fn parse(self, ctx: &mut ExtensionAnchors) -> Result<Self::Parsed, Self::Error> {
        let proto::extensions::SimpleExtensionUrn {
            extension_urn_anchor: anchor,
            urn,
        } = self;

        // The urn is is required and must be valid.
        let urn = Urn::from_str(&urn)?;

        // Construct the parsed simple extension urn.
        let simple_extension_urn = SimpleExtensionUrn {
            urn,
            anchor: Anchor::new(anchor),
        };

        // Make sure the urn is supported by this parse context, resolves and
        // parses, and the anchor is unique.
        ctx.add_simple_extension_urn(&simple_extension_urn)?;

        Ok(simple_extension_urn)
    }
}

impl From<SimpleExtensionUrn> for proto::extensions::SimpleExtensionUrn {
    fn from(simple_extension_urn: SimpleExtensionUrn) -> Self {
        let SimpleExtensionUrn { urn, anchor } = simple_extension_urn;
        proto::extensions::SimpleExtensionUrn {
            urn: urn.to_string(),
            extension_urn_anchor: anchor.into_inner(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse::{Context as _, proto::ExtensionAnchors};

    #[test]
    fn parse() -> Result<(), SimpleExtensionUrnError> {
        let simple_extension_urn = proto::extensions::SimpleExtensionUrn {
            extension_urn_anchor: 1,
            urn: "extension:substrait-rs:test".to_string(),
        };
        let simple_extension_urn = simple_extension_urn.parse(&mut ExtensionAnchors::default())?;
        assert_eq!(simple_extension_urn.anchor(), Anchor::new(1));
        assert_eq!(
            simple_extension_urn.urn().to_string().as_str(),
            "extension:substrait-rs:test"
        );
        Ok(())
    }

    #[test]
    fn invalid_urn() {
        let simple_extension_urn = proto::extensions::SimpleExtensionUrn::default();
        assert_eq!(
            simple_extension_urn.parse(&mut ExtensionAnchors::default()),
            Err(SimpleExtensionUrnError::InvalidUrn(InvalidUrn))
        );
        let simple_extension_urn = proto::extensions::SimpleExtensionUrn {
            extension_urn_anchor: 1,
            urn: "urn::".to_string(),
        };
        assert_eq!(
            simple_extension_urn.parse(&mut ExtensionAnchors::default()),
            Err(SimpleExtensionUrnError::InvalidUrn(InvalidUrn))
        );
    }

    #[test]
    fn duplicate_simple_extension() {
        let mut ctx = ExtensionAnchors::default();
        let simple_extension_urn = proto::extensions::SimpleExtensionUrn {
            extension_urn_anchor: 1,
            urn: "extension:substrait-rs:test".to_string(),
        };
        assert!(ctx.parse(simple_extension_urn.clone()).is_ok());
        assert_eq!(
            ctx.parse(simple_extension_urn),
            Err(SimpleExtensionUrnError::Context(
                ContextError::DuplicateSimpleExtension(Anchor::new(1))
            ))
        );
    }
}