Enum ConversionError

pub enum ConversionError {
    MissingColumn {
        identifier: Box<Ident>,
        table_ref: TableRef,
    },
    MissingSchemaOrTable {
        object_name: ObjectName,
    },
    MissingColumnWithoutTable {
        identifier: Box<Ident>,
    },
    InvalidDataType {
        expected: ColumnType,
        actual: ColumnType,
    },
    DataTypeMismatch {
        left_type: String,
        right_type: String,
    },
    DifferentColumnLength {
        len_a: usize,
        len_b: usize,
    },
    DuplicateResultAlias {
        alias: String,
    },
    NonbooleanWhereClause {
        datatype: ColumnType,
    },
    InvalidOrderBy {
        alias: String,
    },
    InvalidGroupByColumnRef {
        column: String,
    },
    InvalidExpression {
        expression: String,
    },
    ParseError {
        error: String,
    },
    DecimalConversionError {
        source: DecimalError,
    },
    TimestampConversionError {
        source: PoSQLTimestampError,
    },
    ColumnOperationError {
        source: ColumnOperationError,
    },
    PostprocessingError {
        source: PostprocessingError,
    },
    Unprovable {
        error: String,
    },
    UnsupportedOperation {
        message: String,
    },
    IdentifierConversionError {
        error: String,
    },
    AnalyzeError {
        source: AnalyzeError,
    },
}

Errors from converting an intermediate AST into a provable AST.

Variants

MissingColumn

The column is missing in the table

Fields

identifier: Box<Ident>

The missing column identifier

table_ref: TableRef

The table ref

MissingSchemaOrTable

Missing schema or table identifier

Fields

object_name: ObjectName

The ObjectName

MissingColumnWithoutTable

The column is missing (without table information)

Fields

identifier: Box<Ident>

The missing column identifier

InvalidDataType

Invalid data type received

Fields

expected: ColumnType

Expected data type

actual: ColumnType

Actual data type found

DataTypeMismatch

Data types do not match

Fields

left_type: String

The left side datatype

right_type: String

The right side datatype

DifferentColumnLength

Two columns do not have the same length

Fields

len_a: usize

The length of the first column

len_b: usize

The length of the second column

DuplicateResultAlias

Duplicate alias in result columns

Fields

alias: String

The duplicate alias

NonbooleanWhereClause

WHERE clause is not boolean

Fields

datatype: ColumnType

The actual datatype of the WHERE clause

InvalidOrderBy

ORDER BY clause references a non-existent alias

Fields

alias: String

The non-existent alias in the ORDER BY clause

InvalidGroupByColumnRef

GROUP BY clause references a non-existent column

Fields

column: String

The non-existent column in the GROUP BY clause

InvalidExpression

General error for invalid expressions

Fields

expression: String

The invalid expression error

ParseError

General parsing error

Fields

error: String

The underlying error

DecimalConversionError

Errors related to decimal operations

Fields

source: DecimalError

The underlying source error

TimestampConversionError

Errors related to timestamp parsing

Fields

source: PoSQLTimestampError

The underlying source error

ColumnOperationError

Errors related to column operations

Fields

source: ColumnOperationError

The underlying source error

PostprocessingError

Errors related to postprocessing

Fields

source: PostprocessingError

The underlying source error

Unprovable

Query requires unprovable feature

Fields

error: String

The underlying error

UnsupportedOperation

Unsupported operation

Fields

message: String

The operator that is unsupported

IdentifierConversionError

Errors in converting Ident to Identifier

Fields

error: String

The underlying error message

AnalyzeError

Errors in the native analyze process

Fields

source: AnalyzeError

The underlying source error

Implementations

impl ConversionError

pub fn non_numeric_expr_in_agg<S: Into<String>>(dtype: S, func: S) -> Self

Returns a ConversionError::InvalidExpression for non-numeric types used in numeric aggregation functions.

Trait Implementations

impl Debug for ConversionError

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

Formats the value using the given formatter.

impl Display for ConversionError

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

Formats the value using the given formatter.

impl Error for ConversionError

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 ConversionError

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 ConversionError

fn from(error: AnalyzeError) -> Self

Converts to this type from the input type.

impl From<ColumnOperationError> for ConversionError

fn from(error: ColumnOperationError) -> Self

Converts to this type from the input type.

impl From<ConversionError> for String

fn from(error: ConversionError) -> Self

Converts to this type from the input type.

impl From<DecimalError> for ConversionError

fn from(error: DecimalError) -> Self

Converts to this type from the input type.

impl From<IntermediateDecimalError> for ConversionError

fn from(err: IntermediateDecimalError) -> ConversionError

Converts to this type from the input type.

impl From<PoSQLTimestampError> for ConversionError

fn from(error: PoSQLTimestampError) -> Self

Converts to this type from the input type.

impl From<PostprocessingError> for ConversionError

fn from(error: PostprocessingError) -> Self

Converts to this type from the input type.

impl From<String> for ConversionError

fn from(value: String) -> Self

Converts to this type from the input type.

impl PartialEq for ConversionError

fn eq(&self, other: &ConversionError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ConversionError

impl StructuralPartialEq for ConversionError