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

use crate::eval::evaluable::Evaluable;
use crate::eval::expr::EvalExpr;
use crate::eval::EvalContext;
use partiql_value::{Tuple, Value};
use std::borrow::Cow;
use thiserror::Error;

/// All errors that occurred during [`partiql_logical::LogicalPlan`] to [`eval::EvalPlan`] creation.
#[derive(Debug)]
pub struct PlanErr {
    pub errors: Vec<PlanningError>,
}

/// An error that can happen during [`partiql_logical::LogicalPlan`] to [`eval::EvalPlan`] creation.
#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PlanningError {
    /// Feature has not yet been implemented.
    #[error("Not yet implemented: {0}")]
    NotYetImplemented(String),
    /// Internal error that was not due to user input or API violation.
    #[error("Illegal State: {0}")]
    IllegalState(String),
}

/// All errors that occurred during evaluation.
#[derive(Debug)]
pub struct EvalErr {
    pub errors: Vec<EvaluationError>,
}

/// An error that can happen during evaluation.
#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EvaluationError {
    /// Internal error that was not due to user input or API violation.
    #[error("Illegal State: {0}")]
    IllegalState(String),
    /// Malformed evaluation plan with graph containing cycle.
    #[error("Evaluation Error: invalid evaluation plan detected `{0}`")]
    InvalidEvaluationPlan(String),
    /// Feature has not yet been implemented.
    #[error("Not yet implemented: {0}")]
    NotYetImplemented(String),
}

/// Used when an error occurs during the the logical to eval plan conversion. Allows the conversion
/// to continue in order to report multiple errors.
#[derive(Debug)]
pub(crate) struct ErrorNode {}

impl ErrorNode {
    pub(crate) fn new() -> ErrorNode {
        ErrorNode {}
    }
}

impl Evaluable for ErrorNode {
    fn evaluate(&mut self, _ctx: &dyn EvalContext) -> Value {
        panic!("ErrorNode will not be evaluated")
    }

    fn update_input(&mut self, _input: Value, _branch_num: u8, _ctx: &dyn EvalContext) {
        panic!("ErrorNode will not be evaluated")
    }
}

impl EvalExpr for ErrorNode {
    fn evaluate<'a>(&'a self, _bindings: &'a Tuple, _ctx: &'a dyn EvalContext) -> Cow<'a, Value> {
        panic!("ErrorNode will not be evaluated")
    }
}