Enum parser_database::ReferentialAction

#[repr(u8)]
pub enum ReferentialAction {
    Cascade = 1,
    Restrict = 2,
    NoAction = 4,
    SetNull = 8,
    SetDefault = 16,
}

An action describing the way referential integrity is managed in the system.

An action is triggered when a relation constraint gets violated in a way that would make the the data inconsistent, e.g. deleting or updating a referencing record that leaves related records into a wrong state.

@relation(fields: [a], references: [b], onDelete: NoAction, onUpdate: Cascade)
                                                  ^^^^^^^^            ^^^^^^^

Variants

Cascade = 1

Deletes record if dependent record is deleted. Updates relation scalar fields if referenced scalar fields of the dependent record are updated.

Prevents operation (both updates and deletes) from succeeding if any records are connected.

Restrict = 2

Prevents operation (both updates and deletes) from succeeding if any records are connected. This behavior will always result in a runtime error for required relations.

NoAction = 4

Behavior is database specific. Either defers throwing an integrity check error until the end of the transaction or errors immediately. If deferred, this makes it possible to temporarily violate integrity in a transaction while making sure that subsequent operations in the transaction restore integrity.

When using relationMode = “prisma”, NoAction becomes an alias of the emulated Restrict (when supported).

SetNull = 8

Sets relation scalar fields to null if the relation is deleted or updated. This will always result in a runtime error if one or more of the relation scalar fields are required.

SetDefault = 16

Sets relation scalar fields to their default values on update or delete of relation. Will always result in a runtime error if no defaults are provided for any relation scalar fields.

Implementations

impl ReferentialAction

pub fn triggers_modification(self) -> bool

True if the action modifies the related items.

pub fn as_str(self) -> &'static str

The string representation of the referential action in the schema.

pub fn documentation(&self) -> &'static str

The documentation string to display in autocompletion / editor hints.

Trait Implementations

impl AsRef<str> for ReferentialAction

fn as_ref(&self) -> &'static str

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd for ReferentialAction

type Output = BitFlags<ReferentialAction>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitFlag for ReferentialAction

fn empty() -> BitFlags<Self>

Create a BitFlags with no flags set (in other words, with a value of 0).

fn all() -> BitFlags<Self>

Create a BitFlags with all flags set.

impl BitOr for ReferentialAction

type Output = BitFlags<ReferentialAction>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitXor for ReferentialAction

type Output = BitFlags<ReferentialAction>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl Clone for ReferentialAction

fn clone(&self) -> ReferentialAction

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReferentialAction

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

Formats the value using the given formatter.

impl Display for ReferentialAction

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

Formats the value using the given formatter.

impl Not for ReferentialAction

type Output = BitFlags<ReferentialAction>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for ReferentialAction

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl RawBitFlags for ReferentialAction

type Numeric = u8

The underlying integer type.

const EMPTY: Self::Numeric = {transmute(0x00): <relations::ReferentialAction as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: Self::Numeric = {transmute(0x00): <relations::ReferentialAction as enumflags2::_internal::RawBitFlags>::Numeric}

The value used by the Default implementation. Equivalent to EMPTY, unless customized.

const ALL_BITS: Self::Numeric = {transmute(0x1f): <relations::ReferentialAction as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = "BitFlags<ReferentialAction>"

The name of the type for debug formatting purposes.

fn bits(self) -> Self::Numeric

Return the bits as a number type.

impl Copy for ReferentialAction

impl StructuralPartialEq for ReferentialAction