Enum ValidationError

#[non_exhaustive]
pub enum ValidationError {
    DuplicateName {
        name: Box<str>,
    },
    DuplicateTypeName {
        name: ScopedTypeName,
    },
    DuplicateLifecycle {
        lifecycle: Lifecycle,
    },
    IdentifierError {
        error: IdentifierError,
    },
    UnnamedColumn {
        column: RawColumnName,
    },
    TypeHasIncorrectOrdering {
        type_name: RawScopedTypeNameV9,
        ref_: AlgebraicTypeRef,
        bad_type: PrettyAlgebraicType,
    },
    ColumnNotFound {
        table: RawIdentifier,
        def: RawIdentifier,
        column: ColId,
    },
    ColumnDefMalformed {
        column: RawColumnName,
        ty: PrettyAlgebraicType,
        pos: ColId,
        product_type: PrettyAlgebraicType,
    },
    RepeatedPrimaryKey {
        table: RawIdentifier,
    },
    OneAutoInc {
        column: RawColumnName,
    },
    HashIndexUnsupported {
        index: RawIdentifier,
    },
    UniqueConstraintWithoutIndex {
        constraint: Box<str>,
        columns: ColSet,
    },
    DirectIndexOnBadType {
        index: RawIdentifier,
        column: RawIdentifier,
        ty: PrettyAlgebraicType,
    },
    DuplicateColumns {
        def: RawIdentifier,
        columns: ColList,
    },
    InvalidSequenceColumnType {
        sequence: RawIdentifier,
        column: RawColumnName,
        column_type: PrettyAlgebraicType,
    },
    InvalidSequenceRange {
        sequence: RawIdentifier,
        min_value: Option<i128>,
        start: Option<i128>,
        max_value: Option<i128>,
    },
    InvalidProductTypeRef {
        table: RawIdentifier,
        ref_: AlgebraicTypeRef,
    },
    InvalidTypeRef {
        type_name: RawScopedTypeNameV9,
        ref_: AlgebraicTypeRef,
    },
    ScheduledIncorrectColumns {
        table: RawIdentifier,
        columns: ProductType,
    },
    ClientCodegenError {
        location: TypeLocation<'static>,
        error: ClientCodegenError,
    },
    MissingTypeDef {
        ref_: AlgebraicTypeRef,
        ty: PrettyAlgebraicType,
    },
    MissingPrimaryKeyUniqueConstraint {
        column: RawColumnName,
    },
    TableTypeNameMismatch {
        table: Identifier,
    },
    MissingScheduledReducer {
        schedule: Box<str>,
        reducer: Identifier,
    },
    IncorrectScheduledReducerParams {
        reducer: RawIdentifier,
        expected: PrettyAlgebraicType,
        actual: PrettyAlgebraicType,
    },
    TableNameReserved {
        table: Identifier,
    },
    InvalidRowLevelQuery {
        sql: String,
        error: String,
    },
}

A single validation error.

Many variants of this enum store RawIdentifiers rather than Identifiers. This is because we want to support reporting errors about module entities with invalid names.

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.

DuplicateName

Fields

name: Box<str>

DuplicateTypeName

Fields

name: ScopedTypeName

DuplicateLifecycle

Fields

lifecycle: Lifecycle

IdentifierError

Fields

error: IdentifierError

UnnamedColumn

Fields

column: RawColumnName

TypeHasIncorrectOrdering

Fields

type_name: RawScopedTypeNameV9

ref_: AlgebraicTypeRef

bad_type: PrettyAlgebraicType

Could be a sum or product.

ColumnNotFound

Fields

table: RawIdentifier

def: RawIdentifier

column: ColId

ColumnDefMalformed

Fields

column: RawColumnName

ty: PrettyAlgebraicType

pos: ColId

product_type: PrettyAlgebraicType

RepeatedPrimaryKey

Fields

table: RawIdentifier

OneAutoInc

Fields

column: RawColumnName

HashIndexUnsupported

Fields

index: RawIdentifier

UniqueConstraintWithoutIndex

Fields

constraint: Box<str>

columns: ColSet

DirectIndexOnBadType

Fields

index: RawIdentifier

column: RawIdentifier

ty: PrettyAlgebraicType

DuplicateColumns

Fields

def: RawIdentifier

columns: ColList

InvalidSequenceColumnType

Fields

sequence: RawIdentifier

column: RawColumnName

column_type: PrettyAlgebraicType

InvalidSequenceRange

Fields

sequence: RawIdentifier

min_value: Option<i128>

start: Option<i128>

max_value: Option<i128>

InvalidProductTypeRef

Fields

table: RawIdentifier

ref_: AlgebraicTypeRef

InvalidTypeRef

Fields

type_name: RawScopedTypeNameV9

ref_: AlgebraicTypeRef

ScheduledIncorrectColumns

Fields

table: RawIdentifier

columns: ProductType

ClientCodegenError

Fields

location: TypeLocation<'static>

error: ClientCodegenError

MissingTypeDef

Fields

ref_: AlgebraicTypeRef

ty: PrettyAlgebraicType

MissingPrimaryKeyUniqueConstraint

Fields

column: RawColumnName

TableTypeNameMismatch

Fields

table: Identifier

MissingScheduledReducer

Fields

schedule: Box<str>

reducer: Identifier

IncorrectScheduledReducerParams

Fields

reducer: RawIdentifier

expected: PrettyAlgebraicType

actual: PrettyAlgebraicType

TableNameReserved

Fields

table: Identifier

InvalidRowLevelQuery

Fields

sql: String

error: String

Trait Implementations

impl Debug for ValidationError

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

Formats the value using the given formatter.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Error for ValidationError

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

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

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 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 Ord for ValidationError

fn cmp(&self, other: &ValidationError) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ValidationError

fn eq(&self, other: &ValidationError) -> 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 PartialOrd for ValidationError

fn partial_cmp(&self, other: &ValidationError) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for ValidationError

impl StructuralPartialEq for ValidationError