Enum PlannerError 

#[non_exhaustive]
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>,
    },
    UnsupportedAggregatePlan {
        source: AggregatePlanError,
    },
    UnsupportedJoinPlan {
        source: JoinPlanError,
    },
    UnsupportedLogicalPlan {
        node: LogicalPlanNodeKind,
    },
    UnresolvedLogicalPlan,
    CatalogNotSupported,
}

Proof of SQL Planner error

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future 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

UnsupportedAggregatePlan

Returned when an aggregate logical plan cannot be converted.

Fields

source: AggregatePlanError

Specific aggregate conversion error.

UnsupportedJoinPlan

Returned when a join logical plan cannot be converted.

Fields

source: JoinPlanError

Specific join conversion error.

UnsupportedLogicalPlan

Returned when a LogicalPlan node or shape is not supported.

Fields

node: LogicalPlanNodeKind

Kind of node whose particular shape was unsupported.

UnresolvedLogicalPlan

Returned when the LogicalPlan is not resolved

CatalogNotSupported

Returned when catalog is provided since it is not supported

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<AggregatePlanError> for PlannerError

fn from(error: AggregatePlanError) -> Self

Converts to this type from the input type.

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<JoinPlanError> for PlannerError

fn from(error: JoinPlanError) -> 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.