Enum PlannerError

pub enum PlannerError {
    AnalyzeError {
        source: AnalyzeError,
    },
    DecimalError {
        source: DecimalError,
    },
    SqlParserError {
        source: ParserError,
    },
    DataFusionError {
        source: DataFusionError,
    },
    ColumnNotFound,
    TableNotFound {
        table_name: String,
    },
    InvalidPlaceholderId {
        id: String,
    },
    UntypedPlaceholder {
        placeholder: Placeholder,
    },
    UnsupportedDataType {
        data_type: DataType,
    },
    UnsupportedBinaryOperator {
        op: Operator,
    },
    UnsupportedAggregateOperation {
        op: AggregateFunction,
    },
    UnsupportedAggregateFunction {
        function: AggregateFunction,
    },
    UnsupportedLogicalExpression {
        expr: Box<Expr>,
    },
    UnsupportedLogicalPlan {
        plan: Box<LogicalPlan>,
    },
    UnresolvedLogicalPlan,
    CatalogNotSupported,
    PostprocessingError {
        source: PostprocessingError,
    },
}

Proof of SQL Planner error

Variants

AnalyzeError

Returned when the internal analyze process fails

Fields

source: AnalyzeError

Underlying analyze error

DecimalError

Returned when a decimal error occurs

Fields

source: DecimalError

Underlying decimal error

SqlParserError

Returned when sqlparser fails to parse a query

Fields

source: ParserError

Underlying sqlparser error

DataFusionError

Returned when datafusion fails to plan a query

Fields

source: DataFusionError

Underlying datafusion error

ColumnNotFound

Returned if a column is not found

TableNotFound

Returned if a table is not found

Fields

table_name: String

Table name

InvalidPlaceholderId

Returned when a placeholder id is invalid

Fields

id: String

Unsupported placeholder id

UntypedPlaceholder

Returned when a placeholder is untyped

Fields

placeholder: Placeholder

Untyped placeholder

UnsupportedDataType

Returned when a datatype is not supported

Fields

data_type: DataType

Unsupported datatype

UnsupportedBinaryOperator

Returned when a binary operator is not supported

Fields

op: Operator

Unsupported binary operation

UnsupportedAggregateOperation

Returned when the aggregate opetation is not supported

Fields

op: AggregateFunction

Unsupported aggregate operation

UnsupportedAggregateFunction

Returned when the AggregateFunction is not supported

Fields

function: AggregateFunction

Unsupported AggregateFunction

UnsupportedLogicalExpression

Returned when a logical expression is not resolved

Fields

expr: Box<Expr>

Unsupported logical expression

UnsupportedLogicalPlan

Returned when a LogicalPlan is not supported

Fields

plan: Box<LogicalPlan>

Unsupported LogicalPlan

UnresolvedLogicalPlan

Returned when the LogicalPlan is not resolved

CatalogNotSupported

Returned when catalog is provided since it is not supported

PostprocessingError

Returned when error occurs in postprocessing

Fields

source: PostprocessingError

Underlying postprocessing error

Trait Implementations

impl Debug for PlannerError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for PlannerError

fn fmt(&self, __snafu_display_formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for PlannerError

where Self: Debug + Display,

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl ErrorCompat for PlannerError

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

fn iter_chain(&self) -> ChainCompat<'_, '_>

where Self: AsErrorSource,

Returns an iterator for traversing the chain of errors, starting with the current error and continuing with recursive calls to Error::source.

impl From<AnalyzeError> for PlannerError

fn from(error: AnalyzeError) -> Self

Converts to this type from the input type.

impl From<DataFusionError> for PlannerError

fn from(error: DataFusionError) -> Self

Converts to this type from the input type.

impl From<DecimalError> for PlannerError

fn from(error: DecimalError) -> Self

Converts to this type from the input type.

impl From<ParserError> for PlannerError

fn from(error: ParserError) -> Self

Converts to this type from the input type.

impl From<PostprocessingError> for PlannerError

fn from(error: PostprocessingError) -> Self

Converts to this type from the input type.